Option(..),
DynLibLoader(..),
fFlags, xFlags,
+ DPHBackend(..),
-- Configuration of the core-to-core and stg-to-stg phases
CoreToDo(..),
-- misc stuff
machdepCCOpts, picCCOpts,
- supportedLanguages,
+ supportedLanguages, languageOptions,
compilerInfo,
) where
import Config
import CmdLineParser
import Constants ( mAX_CONTEXT_REDUCTION_DEPTH )
-import Panic ( panic, GhcException(..) )
+import Panic
import UniqFM ( UniqFM )
import Util
-import Maybes ( orElse, fromJust )
+import Maybes ( orElse )
import SrcLoc ( SrcSpan )
import Outputable
import {-# SOURCE #-} ErrUtils ( Severity(..), Message, mkLocMessage )
import Data.IORef ( readIORef )
-import Control.Exception ( throwDyn )
import Control.Monad ( when )
import Data.Char
import System.FilePath
-import System.IO ( hPutStrLn, stderr )
+import System.IO ( stderr, hPutChar )
-- -----------------------------------------------------------------------------
-- DynFlags
| Opt_WarnUnusedBinds
| Opt_WarnUnusedImports
| Opt_WarnUnusedMatches
- | Opt_WarnDeprecations
+ | Opt_WarnWarningsDeprecations
+ | Opt_WarnDeprecatedFlags
| Opt_WarnDodgyImports
| Opt_WarnOrphans
| Opt_WarnTabs
+ | Opt_WarnUnrecognisedPragmas
+ | Opt_WarnDodgyForeignImports
-- language opts
| Opt_OverlappingInstances
| Opt_TransformListComp
| Opt_GeneralizedNewtypeDeriving
| Opt_RecursiveDo
+ | Opt_PostfixOperators
| Opt_PatternGuards
| Opt_LiberalTypeSynonyms
| Opt_Rank2Types
| Opt_EmbedManifest
| Opt_RunCPSZ
| Opt_ConvertToZipCfgAndBack
+ | Opt_AutoLinkPackages
-- keeping stuff
| Opt_KeepHiDiffs
mainFunIs :: Maybe String,
ctxtStkDepth :: Int, -- Typechecker context stack depth
+ dphBackend :: DPHBackend,
+
thisPackage :: PackageId,
-- ways
opt_m :: [String],
opt_a :: [String],
opt_l :: [String],
- opt_dep :: [String],
opt_windres :: [String],
-- commands for particular phases
pgm_sysman :: String,
pgm_windres :: String,
+ -- For ghc -M
+ depMakefile :: FilePath,
+ depIncludePkgDeps :: Bool,
+ depExcludeMods :: [ModuleName],
+ depSuffixes :: [String],
+ depWarnings :: Bool,
+
-- Package flags
extraPkgConfs :: [FilePath],
topDir :: FilePath, -- filled in by SysTools
mainFunIs = Nothing,
ctxtStkDepth = mAX_CONTEXT_REDUCTION_DEPTH,
+ dphBackend = DPHPar,
+
thisPackage = mainPackageId,
objectDir = Nothing,
opt_a = [],
opt_m = [],
opt_l = [],
- opt_dep = [],
opt_windres = [],
extraPkgConfs = [],
pgm_sysman = panic "defaultDynFlags: No pgm_sysman",
pgm_windres = panic "defaultDynFlags: No pgm_windres",
-- end of initSysTools values
+ -- ghc -M values
+ depMakefile = "Makefile",
+ depIncludePkgDeps = False,
+ depExcludeMods = [],
+ depSuffixes = [],
+ depWarnings = True,
+ -- end of ghc -M values
haddockOptions = Nothing,
flags = [
+ Opt_AutoLinkPackages,
Opt_ReadUserPackageConf,
Opt_MonoPatBinds, -- Experimentally, I'm making this non-standard
log_action = \severity srcSpan style msg ->
case severity of
- SevInfo -> hPutStrLn stderr (show (msg style))
- SevFatal -> hPutStrLn stderr (show (msg style))
- _ -> hPutStrLn stderr ('\n':show ((mkLocMessage srcSpan msg) style))
+ SevInfo -> printErrs (msg style)
+ SevFatal -> printErrs (msg style)
+ _ -> do
+ hPutChar stderr '\n'
+ printErrs ((mkLocMessage srcSpan msg) style)
+ -- careful (#2302): printErrs prints in UTF-8, whereas
+ -- converting to string first and using hPutStr would
+ -- just emit the low 8 bits of each unicode char.
}
{-
setObjectDir, setHiDir, setStubDir, setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
setPgmP, setPgmL, setPgmF, setPgmc, setPgmm, setPgms, setPgma, setPgml, setPgmdll, setPgmwindres,
- addOptL, addOptP, addOptF, addOptc, addOptm, addOpta, addOptl, addOptdep, addOptwindres,
+ addOptL, addOptP, addOptF, addOptc, addOptm, addOpta, addOptl, addOptwindres,
addCmdlineFramework, addHaddockOpts
:: String -> DynFlags -> DynFlags
setOutputFile, setOutputHi, setDumpPrefixForce
setHiDir f d = d{ hiDir = Just f}
setStubDir f d = d{ stubDir = Just f, includePaths = f : includePaths d }
-- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
- -- #included from the .hc file when compiling with -fvia-C.
+ -- \#included from the .hc file when compiling with -fvia-C.
setObjectSuf f d = d{ objectSuf = f}
setHiSuf f d = d{ hiSuf = f}
addOptm f d = d{ opt_m = f : opt_m d}
addOpta f d = d{ opt_a = f : opt_a d}
addOptl f d = d{ opt_l = f : opt_l d}
-addOptdep f d = d{ opt_dep = f : opt_dep d}
addOptwindres f d = d{ opt_windres = f : opt_windres d}
+setDepMakefile :: FilePath -> DynFlags -> DynFlags
+setDepMakefile f d = d { depMakefile = deOptDep f }
+
+setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
+setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
+
+addDepExcludeMod :: String -> DynFlags -> DynFlags
+addDepExcludeMod m d
+ = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
+
+addDepSuffix :: FilePath -> DynFlags -> DynFlags
+addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
+
+setDepWarnings :: Bool -> DynFlags -> DynFlags
+setDepWarnings b d = d { depWarnings = b }
+
+-- XXX Legacy code:
+-- We used to use "-optdep-flag -optdeparg", so for legacy applications
+-- we need to strip the "-optdep" off of the arg
+deOptDep :: String -> String
+deOptDep x = case maybePrefixMatch "-optdep" x of
+ Just rest -> rest
+ Nothing -> x
+
addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
addHaddockOpts f d = d{ haddockOptions = Just f}
standardWarnings :: [DynFlag]
standardWarnings
- = [ Opt_WarnDeprecations,
+ = [ Opt_WarnWarningsDeprecations,
+ Opt_WarnDeprecatedFlags,
+ Opt_WarnUnrecognisedPragmas,
Opt_WarnOverlappingPatterns,
Opt_WarnMissingFields,
Opt_WarnMissingMethods,
- Opt_WarnDuplicateExports
+ Opt_WarnDuplicateExports,
+ Opt_WarnDodgyForeignImports
]
minusWOpts :: [DynFlag]
Opt_WarnIncompletePatternsRecUpd,
Opt_WarnSimplePatterns,
Opt_WarnMonomorphism,
+ Opt_WarnUnrecognisedPragmas,
Opt_WarnTabs
]
| CoreCSE
| CoreDoRuleCheck Int{-CompilerPhase-} String -- Check for non-application of rules
-- matching this string
- | CoreDoVectorisation
+ | CoreDoVectorisation DPHBackend
| CoreDoNothing -- Useful when building up
| CoreDoPasses [CoreToDo] -- lists of these things
spec_constr = dopt Opt_SpecConstr dflags
liberate_case = dopt Opt_LiberateCase dflags
rule_check = ruleCheck dflags
- vectorisation = dopt Opt_Vectorise dflags
- -- static_args = dopt Opt_StaticArgumentTransformation dflags
+ static_args = dopt Opt_StaticArgumentTransformation dflags
maybe_rule_check phase = runMaybe rule_check (CoreDoRuleCheck phase)
maybe_rule_check phase
]
+ vectorisation
+ = runWhen (dopt Opt_Vectorise dflags)
+ $ CoreDoPasses [ simpl_gently, CoreDoVectorisation (dphBackend dflags) ]
+
+
-- By default, we have 2 phases before phase 0.
-- Want to run with inline phase 2 after the specialiser to give
core_todo =
if opt_level == 0 then
- [runWhen vectorisation (CoreDoPasses [ simpl_gently, CoreDoVectorisation ]),
+ [vectorisation,
simpl_phase 0 ["final"] max_iter]
else {- opt_level >= 1 -} [
-- may expose extra opportunities to float things outwards. However, to fix
-- up the output of the transformation we need at do at least one simplify
-- after this before anything else
- -- runWhen static_args CoreDoStaticArgs,
- -- XXX disabled, see #2321
-
- -- initial simplify: mk specialiser happy: minimum effort please
- simpl_gently,
+ runWhen static_args (CoreDoPasses [ simpl_gently, CoreDoStaticArgs ]),
-- We run vectorisation here for now, but we might also try to run
-- it later
- runWhen vectorisation (CoreDoPasses [ CoreDoVectorisation, simpl_gently ]),
+ vectorisation,
+
+ -- initial simplify: mk specialiser happy: minimum effort please
+ simpl_gently,
-- Specialisation is best done before full laziness
-- so that overloaded functions have all their dictionary lambdas manifest
[ flagName flag | flag <- dynamic_flags, ok (flagOptKind flag) ] ++
map ("fno-"++) flags ++
map ("f"++) flags ++
- map ("X"++) xs ++
- map ("XNo"++) xs
+ map ("X"++) supportedLanguages ++
+ map ("XNo"++) supportedLanguages
where ok (PrefixPred _ _) = False
ok _ = True
- flags = map fst fFlags
- xs = map fst xFlags
+ flags = [ name | (name, _, _) <- fFlags ]
dynamic_flags :: [Flag DynP]
dynamic_flags = [
- Flag "n" (NoArg (setDynFlag Opt_DryRun))
- , Flag "cpp" (NoArg (setDynFlag Opt_Cpp))
- , Flag "F" (NoArg (setDynFlag Opt_Pp))
- , Flag "#include" (HasArg (addCmdlineHCInclude))
- , Flag "v" (OptIntSuffix setVerbosity)
+ Flag "n" (NoArg (setDynFlag Opt_DryRun)) Supported
+ , Flag "cpp" (NoArg (setDynFlag Opt_Cpp)) Supported
+ , Flag "F" (NoArg (setDynFlag Opt_Pp)) Supported
+ , Flag "#include" (HasArg (addCmdlineHCInclude)) Supported
+ , Flag "v" (OptIntSuffix setVerbosity) Supported
------- Specific phases --------------------------------------------
- , Flag "pgmL" (HasArg (upd . setPgmL))
- , Flag "pgmP" (HasArg (upd . setPgmP))
- , Flag "pgmF" (HasArg (upd . setPgmF))
- , Flag "pgmc" (HasArg (upd . setPgmc))
- , Flag "pgmm" (HasArg (upd . setPgmm))
- , Flag "pgms" (HasArg (upd . setPgms))
- , Flag "pgma" (HasArg (upd . setPgma))
- , Flag "pgml" (HasArg (upd . setPgml))
- , Flag "pgmdll" (HasArg (upd . setPgmdll))
- , Flag "pgmwindres" (HasArg (upd . setPgmwindres))
-
- , Flag "optL" (HasArg (upd . addOptL))
- , Flag "optP" (HasArg (upd . addOptP))
- , Flag "optF" (HasArg (upd . addOptF))
- , Flag "optc" (HasArg (upd . addOptc))
- , Flag "optm" (HasArg (upd . addOptm))
- , Flag "opta" (HasArg (upd . addOpta))
- , Flag "optl" (HasArg (upd . addOptl))
- , Flag "optdep" (HasArg (upd . addOptdep))
- , Flag "optwindres" (HasArg (upd . addOptwindres))
+ , Flag "pgmL" (HasArg (upd . setPgmL)) Supported
+ , Flag "pgmP" (HasArg (upd . setPgmP)) Supported
+ , Flag "pgmF" (HasArg (upd . setPgmF)) Supported
+ , Flag "pgmc" (HasArg (upd . setPgmc)) Supported
+ , Flag "pgmm" (HasArg (upd . setPgmm)) Supported
+ , Flag "pgms" (HasArg (upd . setPgms)) Supported
+ , Flag "pgma" (HasArg (upd . setPgma)) Supported
+ , Flag "pgml" (HasArg (upd . setPgml)) Supported
+ , Flag "pgmdll" (HasArg (upd . setPgmdll)) Supported
+ , Flag "pgmwindres" (HasArg (upd . setPgmwindres)) Supported
+
+ , Flag "optL" (HasArg (upd . addOptL)) Supported
+ , Flag "optP" (HasArg (upd . addOptP)) Supported
+ , Flag "optF" (HasArg (upd . addOptF)) Supported
+ , Flag "optc" (HasArg (upd . addOptc)) Supported
+ , Flag "optm" (HasArg (upd . addOptm)) Supported
+ , Flag "opta" (HasArg (upd . addOpta)) Supported
+ , Flag "optl" (HasArg (upd . addOptl)) Supported
+ , Flag "optwindres" (HasArg (upd . addOptwindres)) Supported
, Flag "split-objs"
(NoArg (if can_split then setDynFlag Opt_SplitObjs else return ()))
+ Supported
+
+ -------- ghc -M -----------------------------------------------------
+ , Flag "dep-suffix" (HasArg (upd . addDepSuffix)) Supported
+ , Flag "optdep-s" (HasArg (upd . addDepSuffix))
+ (Deprecated "Use -dep-suffix instead")
+ , Flag "dep-makefile" (HasArg (upd . setDepMakefile)) Supported
+ , Flag "optdep-f" (HasArg (upd . setDepMakefile))
+ (Deprecated "Use -dep-makefile instead")
+ , Flag "optdep-w" (NoArg (upd (setDepWarnings False)))
+ (Deprecated "-optdep-w doesn't do anything")
+ , Flag "include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True))) Supported
+ , Flag "optdep--include-prelude" (NoArg (upd (setDepIncludePkgDeps True)))
+ (Deprecated "Use -include-pkg-deps instead")
+ , Flag "optdep--include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True)))
+ (Deprecated "Use -include-pkg-deps instead")
+ , Flag "exclude-module" (HasArg (upd . addDepExcludeMod)) Supported
+ , Flag "optdep--exclude-module" (HasArg (upd . addDepExcludeMod))
+ (Deprecated "Use -exclude-module instead")
+ , Flag "optdep-x" (HasArg (upd . addDepExcludeMod))
+ (Deprecated "Use -exclude-module instead")
-------- Linking ----------------------------------------------------
, Flag "c" (NoArg (upd $ \d -> d{ ghcLink=NoLink } ))
- , Flag "no-link" (NoArg (upd $ \d -> d{ ghcLink=NoLink } )) -- Dep.
+ Supported
+ , Flag "no-link" (NoArg (upd $ \d -> d{ ghcLink=NoLink } ))
+ (Deprecated "Use -c instead")
, Flag "shared" (NoArg (upd $ \d -> d{ ghcLink=LinkDynLib } ))
+ Supported
, Flag "dynload" (HasArg (upd . parseDynLibLoaderMode))
+ Supported
------- Libraries ---------------------------------------------------
- , Flag "L" (Prefix addLibraryPath )
- , Flag "l" (AnySuffix (\s -> do upd (addOptl s)))
+ , Flag "L" (Prefix addLibraryPath ) Supported
+ , Flag "l" (AnySuffix (\s -> do upd (addOptl s))) Supported
------- Frameworks --------------------------------------------------
-- -framework-path should really be -F ...
- , Flag "framework-path" (HasArg addFrameworkPath )
- , Flag "framework" (HasArg (upd . addCmdlineFramework))
+ , Flag "framework-path" (HasArg addFrameworkPath ) Supported
+ , Flag "framework" (HasArg (upd . addCmdlineFramework)) Supported
------- Output Redirection ------------------------------------------
- , Flag "odir" (HasArg (upd . setObjectDir))
- , Flag "o" (SepArg (upd . setOutputFile . Just))
- , Flag "ohi" (HasArg (upd . setOutputHi . Just ))
- , Flag "osuf" (HasArg (upd . setObjectSuf))
- , Flag "hcsuf" (HasArg (upd . setHcSuf))
- , Flag "hisuf" (HasArg (upd . setHiSuf))
- , Flag "hidir" (HasArg (upd . setHiDir))
- , Flag "tmpdir" (HasArg (upd . setTmpDir))
- , Flag "stubdir" (HasArg (upd . setStubDir))
+ , Flag "odir" (HasArg (upd . setObjectDir)) Supported
+ , Flag "o" (SepArg (upd . setOutputFile . Just)) Supported
+ , Flag "ohi" (HasArg (upd . setOutputHi . Just )) Supported
+ , Flag "osuf" (HasArg (upd . setObjectSuf)) Supported
+ , Flag "hcsuf" (HasArg (upd . setHcSuf)) Supported
+ , Flag "hisuf" (HasArg (upd . setHiSuf)) Supported
+ , Flag "hidir" (HasArg (upd . setHiDir)) Supported
+ , Flag "tmpdir" (HasArg (upd . setTmpDir)) Supported
+ , Flag "stubdir" (HasArg (upd . setStubDir)) Supported
, Flag "ddump-file-prefix" (HasArg (upd . setDumpPrefixForce . Just))
+ Supported
------- Keeping temporary files -------------------------------------
-- These can be singular (think ghc -c) or plural (think ghc --make)
- , Flag "keep-hc-file" (NoArg (setDynFlag Opt_KeepHcFiles))
- , Flag "keep-hc-files" (NoArg (setDynFlag Opt_KeepHcFiles))
- , Flag "keep-s-file" (NoArg (setDynFlag Opt_KeepSFiles))
- , Flag "keep-s-files" (NoArg (setDynFlag Opt_KeepSFiles))
- , Flag "keep-raw-s-file" (NoArg (setDynFlag Opt_KeepRawSFiles))
- , Flag "keep-raw-s-files" (NoArg (setDynFlag Opt_KeepRawSFiles))
+ , Flag "keep-hc-file" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
+ , Flag "keep-hc-files" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
+ , Flag "keep-s-file" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
+ , Flag "keep-s-files" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
+ , Flag "keep-raw-s-file" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
+ , Flag "keep-raw-s-files" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
-- This only makes sense as plural
- , Flag "keep-tmp-files" (NoArg (setDynFlag Opt_KeepTmpFiles))
+ , Flag "keep-tmp-files" (NoArg (setDynFlag Opt_KeepTmpFiles)) Supported
------- Miscellaneous ----------------------------------------------
- , Flag "no-hs-main" (NoArg (setDynFlag Opt_NoHsMain))
- , Flag "main-is" (SepArg setMainIs )
- , Flag "haddock" (NoArg (setDynFlag Opt_Haddock))
- , Flag "haddock-opts" (HasArg (upd . addHaddockOpts))
- , Flag "hpcdir" (SepArg setOptHpcDir)
-
- ------- recompilation checker (DEPRECATED, use -fforce-recomp) -----
+ , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages)) Supported
+ , Flag "no-hs-main" (NoArg (setDynFlag Opt_NoHsMain)) Supported
+ , Flag "main-is" (SepArg setMainIs ) Supported
+ , Flag "haddock" (NoArg (setDynFlag Opt_Haddock)) Supported
+ , Flag "haddock-opts" (HasArg (upd . addHaddockOpts)) Supported
+ , Flag "hpcdir" (SepArg setOptHpcDir) Supported
+
+ ------- recompilation checker --------------------------------------
, Flag "recomp" (NoArg (unSetDynFlag Opt_ForceRecomp))
+ (Deprecated "Use -fno-force-recomp instead")
, Flag "no-recomp" (NoArg (setDynFlag Opt_ForceRecomp))
+ (Deprecated "Use -fforce-recomp instead")
------- Packages ----------------------------------------------------
- , Flag "package-conf" (HasArg extraPkgConf_)
+ , Flag "package-conf" (HasArg extraPkgConf_) Supported
, Flag "no-user-package-conf" (NoArg (unSetDynFlag Opt_ReadUserPackageConf))
- , Flag "package-name" (HasArg (upd . setPackageName))
- , Flag "package" (HasArg exposePackage)
- , Flag "hide-package" (HasArg hidePackage)
+ Supported
+ , Flag "package-name" (HasArg (upd . setPackageName)) Supported
+ , Flag "package" (HasArg exposePackage) Supported
+ , Flag "hide-package" (HasArg hidePackage) Supported
, Flag "hide-all-packages" (NoArg (setDynFlag Opt_HideAllPackages))
+ Supported
, Flag "ignore-package" (HasArg ignorePackage)
- , Flag "syslib" (HasArg exposePackage) -- for compatibility
+ Supported
+ , Flag "syslib" (HasArg exposePackage)
+ (Deprecated "Use -package instead")
------ HsCpp opts ---------------------------------------------------
- , Flag "D" (AnySuffix (upd . addOptP))
- , Flag "U" (AnySuffix (upd . addOptP))
+ , Flag "D" (AnySuffix (upd . addOptP)) Supported
+ , Flag "U" (AnySuffix (upd . addOptP)) Supported
------- Include/Import Paths ----------------------------------------
- , Flag "I" (Prefix addIncludePath)
- , Flag "i" (OptPrefix addImportPath )
+ , Flag "I" (Prefix addIncludePath) Supported
+ , Flag "i" (OptPrefix addImportPath ) Supported
------ Debugging ----------------------------------------------------
- , Flag "dstg-stats" (NoArg (setDynFlag Opt_StgStats))
+ , Flag "dstg-stats" (NoArg (setDynFlag Opt_StgStats)) Supported
, Flag "ddump-cmm" (setDumpFlag Opt_D_dump_cmm)
+ Supported
, Flag "ddump-cmmz" (setDumpFlag Opt_D_dump_cmmz)
+ Supported
, Flag "ddump-cmmz-pretty" (setDumpFlag Opt_D_dump_cmmz_pretty)
+ Supported
, Flag "ddump-cps-cmm" (setDumpFlag Opt_D_dump_cps_cmm)
+ Supported
, Flag "ddump-cvt-cmm" (setDumpFlag Opt_D_dump_cvt_cmm)
+ Supported
, Flag "ddump-asm" (setDumpFlag Opt_D_dump_asm)
+ Supported
, Flag "ddump-asm-native" (setDumpFlag Opt_D_dump_asm_native)
+ Supported
, Flag "ddump-asm-liveness" (setDumpFlag Opt_D_dump_asm_liveness)
+ Supported
, Flag "ddump-asm-coalesce" (setDumpFlag Opt_D_dump_asm_coalesce)
+ Supported
, Flag "ddump-asm-regalloc" (setDumpFlag Opt_D_dump_asm_regalloc)
+ Supported
, Flag "ddump-asm-conflicts" (setDumpFlag Opt_D_dump_asm_conflicts)
+ Supported
, Flag "ddump-asm-regalloc-stages"
(setDumpFlag Opt_D_dump_asm_regalloc_stages)
+ Supported
, Flag "ddump-asm-stats" (setDumpFlag Opt_D_dump_asm_stats)
+ Supported
, Flag "ddump-cpranal" (setDumpFlag Opt_D_dump_cpranal)
+ Supported
, Flag "ddump-deriv" (setDumpFlag Opt_D_dump_deriv)
+ Supported
, Flag "ddump-ds" (setDumpFlag Opt_D_dump_ds)
+ Supported
, Flag "ddump-flatC" (setDumpFlag Opt_D_dump_flatC)
+ Supported
, Flag "ddump-foreign" (setDumpFlag Opt_D_dump_foreign)
+ Supported
, Flag "ddump-inlinings" (setDumpFlag Opt_D_dump_inlinings)
+ Supported
, Flag "ddump-rule-firings" (setDumpFlag Opt_D_dump_rule_firings)
+ Supported
, Flag "ddump-occur-anal" (setDumpFlag Opt_D_dump_occur_anal)
+ Supported
, Flag "ddump-parsed" (setDumpFlag Opt_D_dump_parsed)
+ Supported
, Flag "ddump-rn" (setDumpFlag Opt_D_dump_rn)
+ Supported
, Flag "ddump-simpl" (setDumpFlag Opt_D_dump_simpl)
+ Supported
, Flag "ddump-simpl-iterations" (setDumpFlag Opt_D_dump_simpl_iterations)
+ Supported
, Flag "ddump-simpl-phases" (OptPrefix setDumpSimplPhases)
+ Supported
, Flag "ddump-spec" (setDumpFlag Opt_D_dump_spec)
+ Supported
, Flag "ddump-prep" (setDumpFlag Opt_D_dump_prep)
+ Supported
, Flag "ddump-stg" (setDumpFlag Opt_D_dump_stg)
+ Supported
, Flag "ddump-stranal" (setDumpFlag Opt_D_dump_stranal)
+ Supported
, Flag "ddump-tc" (setDumpFlag Opt_D_dump_tc)
+ Supported
, Flag "ddump-types" (setDumpFlag Opt_D_dump_types)
+ Supported
, Flag "ddump-rules" (setDumpFlag Opt_D_dump_rules)
+ Supported
, Flag "ddump-cse" (setDumpFlag Opt_D_dump_cse)
+ Supported
, Flag "ddump-worker-wrapper" (setDumpFlag Opt_D_dump_worker_wrapper)
+ Supported
, Flag "ddump-rn-trace" (setDumpFlag Opt_D_dump_rn_trace)
+ Supported
, Flag "ddump-if-trace" (setDumpFlag Opt_D_dump_if_trace)
+ Supported
, Flag "ddump-tc-trace" (setDumpFlag Opt_D_dump_tc_trace)
+ Supported
, Flag "ddump-splices" (setDumpFlag Opt_D_dump_splices)
+ Supported
, Flag "ddump-rn-stats" (setDumpFlag Opt_D_dump_rn_stats)
+ Supported
, Flag "ddump-opt-cmm" (setDumpFlag Opt_D_dump_opt_cmm)
+ Supported
, Flag "ddump-simpl-stats" (setDumpFlag Opt_D_dump_simpl_stats)
+ Supported
, Flag "ddump-bcos" (setDumpFlag Opt_D_dump_BCOs)
+ Supported
, Flag "dsource-stats" (setDumpFlag Opt_D_source_stats)
+ Supported
, Flag "dverbose-core2core" (NoArg setVerboseCore2Core)
+ Supported
, Flag "dverbose-stg2stg" (setDumpFlag Opt_D_verbose_stg2stg)
+ Supported
, Flag "ddump-hi" (setDumpFlag Opt_D_dump_hi)
+ Supported
, Flag "ddump-minimal-imports" (setDumpFlag Opt_D_dump_minimal_imports)
+ Supported
, Flag "ddump-vect" (setDumpFlag Opt_D_dump_vect)
+ Supported
, Flag "ddump-hpc" (setDumpFlag Opt_D_dump_hpc)
+ Supported
, Flag "ddump-mod-cycles" (setDumpFlag Opt_D_dump_mod_cycles)
+ Supported
, Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
+ Supported
, Flag "ddump-to-file" (setDumpFlag Opt_DumpToFile)
+ Supported
, Flag "ddump-hi-diffs" (setDumpFlag Opt_D_dump_hi_diffs)
+ Supported
, Flag "dcore-lint" (NoArg (setDynFlag Opt_DoCoreLinting))
+ Supported
, Flag "dstg-lint" (NoArg (setDynFlag Opt_DoStgLinting))
+ Supported
, Flag "dcmm-lint" (NoArg (setDynFlag Opt_DoCmmLinting))
+ Supported
, Flag "dasm-lint" (NoArg (setDynFlag Opt_DoAsmLinting))
+ Supported
, Flag "dshow-passes"
(NoArg (do setDynFlag Opt_ForceRecomp
setVerbosity (Just 2)))
+ Supported
, Flag "dfaststring-stats" (NoArg (setDynFlag Opt_D_faststring_stats))
+ Supported
------ Machine dependant (-m<blah>) stuff ---------------------------
, Flag "monly-2-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 2}) ))
+ Supported
, Flag "monly-3-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 3}) ))
+ Supported
, Flag "monly-4-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 4}) ))
+ Supported
------ Warning opts -------------------------------------------------
, Flag "W" (NoArg (mapM_ setDynFlag minusWOpts))
+ Supported
, Flag "Werror" (NoArg (setDynFlag Opt_WarnIsError))
+ Supported
, Flag "Wwarn" (NoArg (unSetDynFlag Opt_WarnIsError))
+ Supported
, Flag "Wall" (NoArg (mapM_ setDynFlag minusWallOpts))
- , Flag "Wnot" (NoArg (mapM_ unSetDynFlag minusWallOpts)) -- DEPRECATED
+ Supported
+ , Flag "Wnot" (NoArg (mapM_ unSetDynFlag minusWallOpts))
+ (Deprecated "Use -w instead")
, Flag "w" (NoArg (mapM_ unSetDynFlag minuswRemovesOpts))
+ Supported
------ Optimisation flags ------------------------------------------
- , Flag "O" (NoArg (upd (setOptLevel 1)))
- , Flag "Onot" (NoArg (upd (setOptLevel 0))) -- deprecated
- , Flag "Odph" (NoArg (upd setDPHOpt))
+ , Flag "O" (NoArg (upd (setOptLevel 1))) Supported
+ , Flag "Onot" (NoArg (upd (setOptLevel 0)))
+ (Deprecated "Use -O0 instead")
+ , Flag "Odph" (NoArg (upd setDPHOpt)) Supported
, Flag "O" (OptIntSuffix (\mb_n -> upd (setOptLevel (mb_n `orElse` 1))))
+ Supported
-- If the number is missing, use 1
, Flag "fsimplifier-phases"
(IntSuffix (\n -> upd (\dfs -> dfs{ simplPhases = n })))
+ Supported
, Flag "fmax-simplifier-iterations"
(IntSuffix (\n -> upd (\dfs -> dfs{ maxSimplIterations = n })))
+ Supported
, Flag "fspec-constr-threshold"
(IntSuffix (\n -> upd (\dfs -> dfs{ specConstrThreshold = Just n })))
+ Supported
, Flag "fno-spec-constr-threshold"
(NoArg (upd (\dfs -> dfs{ specConstrThreshold = Nothing })))
+ Supported
, Flag "fspec-constr-count"
(IntSuffix (\n -> upd (\dfs -> dfs{ specConstrCount = Just n })))
+ Supported
, Flag "fno-spec-constr-count"
(NoArg (upd (\dfs -> dfs{ specConstrCount = Nothing })))
+ Supported
, Flag "fliberate-case-threshold"
(IntSuffix (\n -> upd (\dfs -> dfs{ liberateCaseThreshold = Just n })))
+ Supported
, Flag "fno-liberate-case-threshold"
(NoArg (upd (\dfs -> dfs{ liberateCaseThreshold = Nothing })))
+ Supported
, Flag "frule-check"
(SepArg (\s -> upd (\dfs -> dfs{ ruleCheck = Just s })))
+ Supported
, Flag "fcontext-stack"
(IntSuffix $ \n -> upd $ \dfs -> dfs{ ctxtStkDepth = n })
+ Supported
+
+ ------ DPH flags ----------------------------------------------------
+
+ , Flag "fdph-seq"
+ (NoArg (upd (setDPHBackend DPHSeq)))
+ Supported
+ , Flag "fdph-par"
+ (NoArg (upd (setDPHBackend DPHPar)))
+ Supported
------ Compiler flags -----------------------------------------------
- , Flag "fasm" (NoArg (setObjTarget HscAsm))
- , Flag "fvia-c" (NoArg (setObjTarget HscC))
- , Flag "fvia-C" (NoArg (setObjTarget HscC))
+ , Flag "fasm" (NoArg (setObjTarget HscAsm)) Supported
+ , Flag "fvia-c" (NoArg (setObjTarget HscC)) Supported
+ , Flag "fvia-C" (NoArg (setObjTarget HscC)) Supported
- , Flag "fno-code" (NoArg (setTarget HscNothing))
- , Flag "fbyte-code" (NoArg (setTarget HscInterpreted))
- , Flag "fobject-code" (NoArg (setTarget defaultHscTarget))
+ , Flag "fno-code" (NoArg (setTarget HscNothing)) Supported
+ , Flag "fbyte-code" (NoArg (setTarget HscInterpreted)) Supported
+ , Flag "fobject-code" (NoArg (setTarget defaultHscTarget)) Supported
, Flag "fglasgow-exts" (NoArg (mapM_ setDynFlag glasgowExtsFlags))
+ Supported
, Flag "fno-glasgow-exts" (NoArg (mapM_ unSetDynFlag glasgowExtsFlags))
-
- -- the rest of the -f* and -fno-* flags
- , Flag "f"
- (PrefixPred (isFlag fFlags)
- (\f -> setDynFlag (getFlag fFlags f)))
- , Flag "f"
- (PrefixPred (isPrefFlag "no-" fFlags)
- (\f -> unSetDynFlag (getPrefFlag "no-" fFlags f)))
-
- -- the -X* and -XNo* flags
- , Flag "X"
- (PrefixPred (isFlag xFlags)
- (\f -> setDynFlag (getFlag xFlags f)))
- , Flag "X"
- (PrefixPred (isPrefFlag "No" xFlags)
- (\f -> unSetDynFlag (getPrefFlag "No" xFlags f)))
+ Supported
]
+ ++ map (mkFlag True "f" setDynFlag ) fFlags
+ ++ map (mkFlag False "fno-" unSetDynFlag) fFlags
+ ++ map (mkFlag True "X" setDynFlag ) xFlags
+ ++ map (mkFlag False "XNo" unSetDynFlag) xFlags
+
+mkFlag :: Bool -- True => turn it on, False => turn it off
+ -> String
+ -> (DynFlag -> DynP ())
+ -> (String, DynFlag, Bool -> Deprecated)
+ -> Flag DynP
+mkFlag turnOn flagPrefix f (name, dynflag, deprecated)
+ = Flag (flagPrefix ++ name) (NoArg (f dynflag)) (deprecated turnOn)
+
+deprecatedForLanguage :: String -> Bool -> Deprecated
+deprecatedForLanguage lang turnOn =
+ Deprecated ("Use the " ++ prefix ++ lang ++ " language instead")
+ where prefix = if turnOn then "" else "No"
-- these -f<blah> flags can all be reversed with -fno-<blah>
-fFlags :: [(String, DynFlag)]
+fFlags :: [(String, DynFlag, Bool -> Deprecated)]
fFlags = [
- ( "warn-dodgy-imports", Opt_WarnDodgyImports ),
- ( "warn-duplicate-exports", Opt_WarnDuplicateExports ),
- ( "warn-hi-shadowing", Opt_WarnHiShadows ),
- ( "warn-implicit-prelude", Opt_WarnImplicitPrelude ),
- ( "warn-incomplete-patterns", Opt_WarnIncompletePatterns ),
- ( "warn-incomplete-record-updates", Opt_WarnIncompletePatternsRecUpd ),
- ( "warn-missing-fields", Opt_WarnMissingFields ),
- ( "warn-missing-methods", Opt_WarnMissingMethods ),
- ( "warn-missing-signatures", Opt_WarnMissingSigs ),
- ( "warn-name-shadowing", Opt_WarnNameShadowing ),
- ( "warn-overlapping-patterns", Opt_WarnOverlappingPatterns ),
- ( "warn-simple-patterns", Opt_WarnSimplePatterns ),
- ( "warn-type-defaults", Opt_WarnTypeDefaults ),
- ( "warn-monomorphism-restriction", Opt_WarnMonomorphism ),
- ( "warn-unused-binds", Opt_WarnUnusedBinds ),
- ( "warn-unused-imports", Opt_WarnUnusedImports ),
- ( "warn-unused-matches", Opt_WarnUnusedMatches ),
- ( "warn-deprecations", Opt_WarnDeprecations ),
- ( "warn-orphans", Opt_WarnOrphans ),
- ( "warn-tabs", Opt_WarnTabs ),
- ( "print-explicit-foralls", Opt_PrintExplicitForalls ),
- ( "strictness", Opt_Strictness ),
- ( "static-argument-transformation", Opt_StaticArgumentTransformation ),
- ( "full-laziness", Opt_FullLaziness ),
- ( "liberate-case", Opt_LiberateCase ),
- ( "spec-constr", Opt_SpecConstr ),
- ( "cse", Opt_CSE ),
- ( "ignore-interface-pragmas", Opt_IgnoreInterfacePragmas ),
- ( "omit-interface-pragmas", Opt_OmitInterfacePragmas ),
- ( "do-lambda-eta-expansion", Opt_DoLambdaEtaExpansion ),
- ( "ignore-asserts", Opt_IgnoreAsserts ),
- ( "do-eta-reduction", Opt_DoEtaReduction ),
- ( "case-merge", Opt_CaseMerge ),
- ( "unbox-strict-fields", Opt_UnboxStrictFields ),
- ( "method-sharing", Opt_MethodSharing ),
- ( "dicts-cheap", Opt_DictsCheap ),
- ( "excess-precision", Opt_ExcessPrecision ),
- ( "asm-mangling", Opt_DoAsmMangling ),
- ( "print-bind-result", Opt_PrintBindResult ),
- ( "force-recomp", Opt_ForceRecomp ),
- ( "hpc-no-auto", Opt_Hpc_No_Auto ),
- ( "rewrite-rules", Opt_RewriteRules ),
- ( "break-on-exception", Opt_BreakOnException ),
- ( "break-on-error", Opt_BreakOnError ),
- ( "print-evld-with-show", Opt_PrintEvldWithShow ),
- ( "print-bind-contents", Opt_PrintBindContents ),
- ( "run-cps", Opt_RunCPSZ ),
- ( "convert-to-zipper-and-back", Opt_ConvertToZipCfgAndBack),
- ( "vectorise", Opt_Vectorise ),
- ( "regs-graph", Opt_RegsGraph),
- ( "regs-iterative", Opt_RegsIterative),
- -- Deprecated in favour of -XTemplateHaskell:
- ( "th", Opt_TemplateHaskell ),
- -- Deprecated in favour of -XForeignFunctionInterface:
- ( "fi", Opt_ForeignFunctionInterface ),
- -- Deprecated in favour of -XForeignFunctionInterface:
- ( "ffi", Opt_ForeignFunctionInterface ),
- -- Deprecated in favour of -XArrows:
- ( "arrows", Opt_Arrows ),
- -- Deprecated in favour of -XGenerics:
- ( "generics", Opt_Generics ),
- -- Deprecated in favour of -XImplicitPrelude:
- ( "implicit-prelude", Opt_ImplicitPrelude ),
- -- Deprecated in favour of -XBangPatterns:
- ( "bang-patterns", Opt_BangPatterns ),
- -- Deprecated in favour of -XMonomorphismRestriction:
- ( "monomorphism-restriction", Opt_MonomorphismRestriction ),
- -- Deprecated in favour of -XMonoPatBinds:
- ( "mono-pat-binds", Opt_MonoPatBinds ),
- -- Deprecated in favour of -XExtendedDefaultRules:
- ( "extended-default-rules", Opt_ExtendedDefaultRules ),
- -- Deprecated in favour of -XImplicitParams:
- ( "implicit-params", Opt_ImplicitParams ),
- -- Deprecated in favour of -XScopedTypeVariables:
- ( "scoped-type-variables", Opt_ScopedTypeVariables ),
- -- Deprecated in favour of -XPArr:
- ( "parr", Opt_PArr ),
- -- Deprecated in favour of -XOverlappingInstances:
- ( "allow-overlapping-instances", Opt_OverlappingInstances ),
- -- Deprecated in favour of -XUndecidableInstances:
- ( "allow-undecidable-instances", Opt_UndecidableInstances ),
- -- Deprecated in favour of -XIncoherentInstances:
- ( "allow-incoherent-instances", Opt_IncoherentInstances ),
- ( "gen-manifest", Opt_GenManifest ),
- ( "embed-manifest", Opt_EmbedManifest )
+ ( "warn-dodgy-foreign-imports", Opt_WarnDodgyForeignImports, const Supported ),
+ ( "warn-dodgy-imports", Opt_WarnDodgyImports, const Supported ),
+ ( "warn-duplicate-exports", Opt_WarnDuplicateExports, const Supported ),
+ ( "warn-hi-shadowing", Opt_WarnHiShadows, const Supported ),
+ ( "warn-implicit-prelude", Opt_WarnImplicitPrelude, const Supported ),
+ ( "warn-incomplete-patterns", Opt_WarnIncompletePatterns, const Supported ),
+ ( "warn-incomplete-record-updates", Opt_WarnIncompletePatternsRecUpd, const Supported ),
+ ( "warn-missing-fields", Opt_WarnMissingFields, const Supported ),
+ ( "warn-missing-methods", Opt_WarnMissingMethods, const Supported ),
+ ( "warn-missing-signatures", Opt_WarnMissingSigs, const Supported ),
+ ( "warn-name-shadowing", Opt_WarnNameShadowing, const Supported ),
+ ( "warn-overlapping-patterns", Opt_WarnOverlappingPatterns, const Supported ),
+ ( "warn-simple-patterns", Opt_WarnSimplePatterns, const Supported ),
+ ( "warn-type-defaults", Opt_WarnTypeDefaults, const Supported ),
+ ( "warn-monomorphism-restriction", Opt_WarnMonomorphism, const Supported ),
+ ( "warn-unused-binds", Opt_WarnUnusedBinds, const Supported ),
+ ( "warn-unused-imports", Opt_WarnUnusedImports, const Supported ),
+ ( "warn-unused-matches", Opt_WarnUnusedMatches, const Supported ),
+ ( "warn-warnings-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
+ ( "warn-deprecated-flags", Opt_WarnDeprecatedFlags, const Supported ),
+ ( "warn-orphans", Opt_WarnOrphans, const Supported ),
+ ( "warn-tabs", Opt_WarnTabs, const Supported ),
+ ( "warn-unrecognised-pragmas", Opt_WarnUnrecognisedPragmas, const Supported ),
+ ( "print-explicit-foralls", Opt_PrintExplicitForalls, const Supported ),
+ ( "strictness", Opt_Strictness, const Supported ),
+ ( "static-argument-transformation", Opt_StaticArgumentTransformation, const Supported ),
+ ( "full-laziness", Opt_FullLaziness, const Supported ),
+ ( "liberate-case", Opt_LiberateCase, const Supported ),
+ ( "spec-constr", Opt_SpecConstr, const Supported ),
+ ( "cse", Opt_CSE, const Supported ),
+ ( "ignore-interface-pragmas", Opt_IgnoreInterfacePragmas, const Supported ),
+ ( "omit-interface-pragmas", Opt_OmitInterfacePragmas, const Supported ),
+ ( "do-lambda-eta-expansion", Opt_DoLambdaEtaExpansion, const Supported ),
+ ( "ignore-asserts", Opt_IgnoreAsserts, const Supported ),
+ ( "do-eta-reduction", Opt_DoEtaReduction, const Supported ),
+ ( "case-merge", Opt_CaseMerge, const Supported ),
+ ( "unbox-strict-fields", Opt_UnboxStrictFields, const Supported ),
+ ( "method-sharing", Opt_MethodSharing, const Supported ),
+ ( "dicts-cheap", Opt_DictsCheap, const Supported ),
+ ( "excess-precision", Opt_ExcessPrecision, const Supported ),
+ ( "asm-mangling", Opt_DoAsmMangling, const Supported ),
+ ( "print-bind-result", Opt_PrintBindResult, const Supported ),
+ ( "force-recomp", Opt_ForceRecomp, const Supported ),
+ ( "hpc-no-auto", Opt_Hpc_No_Auto, const Supported ),
+ ( "rewrite-rules", Opt_RewriteRules, const Supported ),
+ ( "break-on-exception", Opt_BreakOnException, const Supported ),
+ ( "break-on-error", Opt_BreakOnError, const Supported ),
+ ( "print-evld-with-show", Opt_PrintEvldWithShow, const Supported ),
+ ( "print-bind-contents", Opt_PrintBindContents, const Supported ),
+ ( "run-cps", Opt_RunCPSZ, const Supported ),
+ ( "convert-to-zipper-and-back", Opt_ConvertToZipCfgAndBack, const Supported ),
+ ( "vectorise", Opt_Vectorise, const Supported ),
+ ( "regs-graph", Opt_RegsGraph, const Supported ),
+ ( "regs-iterative", Opt_RegsIterative, const Supported ),
+ ( "th", Opt_TemplateHaskell,
+ deprecatedForLanguage "TemplateHaskell" ),
+ ( "fi", Opt_ForeignFunctionInterface,
+ deprecatedForLanguage "ForeignFunctionInterface" ),
+ ( "ffi", Opt_ForeignFunctionInterface,
+ deprecatedForLanguage "ForeignFunctionInterface" ),
+ ( "arrows", Opt_Arrows,
+ deprecatedForLanguage "Arrows" ),
+ ( "generics", Opt_Generics,
+ deprecatedForLanguage "Generics" ),
+ ( "implicit-prelude", Opt_ImplicitPrelude,
+ deprecatedForLanguage "ImplicitPrelude" ),
+ ( "bang-patterns", Opt_BangPatterns,
+ deprecatedForLanguage "BangPatterns" ),
+ ( "monomorphism-restriction", Opt_MonomorphismRestriction,
+ deprecatedForLanguage "MonomorphismRestriction" ),
+ ( "mono-pat-binds", Opt_MonoPatBinds,
+ deprecatedForLanguage "MonoPatBinds" ),
+ ( "extended-default-rules", Opt_ExtendedDefaultRules,
+ deprecatedForLanguage "ExtendedDefaultRules" ),
+ ( "implicit-params", Opt_ImplicitParams,
+ deprecatedForLanguage "ImplicitParams" ),
+ ( "scoped-type-variables", Opt_ScopedTypeVariables,
+ deprecatedForLanguage "ScopedTypeVariables" ),
+ ( "parr", Opt_PArr,
+ deprecatedForLanguage "PArr" ),
+ ( "allow-overlapping-instances", Opt_OverlappingInstances,
+ deprecatedForLanguage "OverlappingInstances" ),
+ ( "allow-undecidable-instances", Opt_UndecidableInstances,
+ deprecatedForLanguage "UndecidableInstances" ),
+ ( "allow-incoherent-instances", Opt_IncoherentInstances,
+ deprecatedForLanguage "IncoherentInstances" ),
+ ( "gen-manifest", Opt_GenManifest, const Supported ),
+ ( "embed-manifest", Opt_EmbedManifest, const Supported )
]
supportedLanguages :: [String]
-supportedLanguages = map fst xFlags
+supportedLanguages = [ name | (name, _, _) <- xFlags ]
+
+-- This may contain duplicates
+languageOptions :: [DynFlag]
+languageOptions = [ dynFlag | (_, dynFlag, _) <- xFlags ]
-- These -X<blah> flags can all be reversed with -XNo<blah>
-xFlags :: [(String, DynFlag)]
+xFlags :: [(String, DynFlag, Bool -> Deprecated)]
xFlags = [
- ( "CPP", Opt_Cpp ),
- ( "PatternGuards", Opt_PatternGuards ),
- ( "UnicodeSyntax", Opt_UnicodeSyntax ),
- ( "MagicHash", Opt_MagicHash ),
- ( "PolymorphicComponents", Opt_PolymorphicComponents ),
- ( "ExistentialQuantification", Opt_ExistentialQuantification ),
- ( "KindSignatures", Opt_KindSignatures ),
- ( "PatternSignatures", Opt_PatternSignatures ),
- ( "EmptyDataDecls", Opt_EmptyDataDecls ),
- ( "ParallelListComp", Opt_ParallelListComp ),
- ( "TransformListComp", Opt_TransformListComp ),
- ( "ForeignFunctionInterface", Opt_ForeignFunctionInterface ),
- ( "UnliftedFFITypes", Opt_UnliftedFFITypes ),
- ( "LiberalTypeSynonyms", Opt_LiberalTypeSynonyms ),
- ( "Rank2Types", Opt_Rank2Types ),
- ( "RankNTypes", Opt_RankNTypes ),
- ( "ImpredicativeTypes", Opt_ImpredicativeTypes ),
- ( "TypeOperators", Opt_TypeOperators ),
- ( "RecursiveDo", Opt_RecursiveDo ),
- ( "Arrows", Opt_Arrows ),
- ( "PArr", Opt_PArr ),
- ( "TemplateHaskell", Opt_TemplateHaskell ),
- ( "QuasiQuotes", Opt_QuasiQuotes ),
- ( "Generics", Opt_Generics ),
+ ( "CPP", Opt_Cpp, const Supported ),
+ ( "PostfixOperators", Opt_PostfixOperators, const Supported ),
+ ( "PatternGuards", Opt_PatternGuards, const Supported ),
+ ( "UnicodeSyntax", Opt_UnicodeSyntax, const Supported ),
+ ( "MagicHash", Opt_MagicHash, const Supported ),
+ ( "PolymorphicComponents", Opt_PolymorphicComponents, const Supported ),
+ ( "ExistentialQuantification", Opt_ExistentialQuantification, const Supported ),
+ ( "KindSignatures", Opt_KindSignatures, const Supported ),
+ ( "PatternSignatures", Opt_PatternSignatures, const Supported ),
+ ( "EmptyDataDecls", Opt_EmptyDataDecls, const Supported ),
+ ( "ParallelListComp", Opt_ParallelListComp, const Supported ),
+ ( "TransformListComp", Opt_TransformListComp, const Supported ),
+ ( "ForeignFunctionInterface", Opt_ForeignFunctionInterface, const Supported ),
+ ( "UnliftedFFITypes", Opt_UnliftedFFITypes, const Supported ),
+ ( "LiberalTypeSynonyms", Opt_LiberalTypeSynonyms, const Supported ),
+ ( "Rank2Types", Opt_Rank2Types, const Supported ),
+ ( "RankNTypes", Opt_RankNTypes, const Supported ),
+ ( "ImpredicativeTypes", Opt_ImpredicativeTypes, const Supported ),
+ ( "TypeOperators", Opt_TypeOperators, const Supported ),
+ ( "RecursiveDo", Opt_RecursiveDo, const Supported ),
+ ( "Arrows", Opt_Arrows, const Supported ),
+ ( "PArr", Opt_PArr, const Supported ),
+ ( "TemplateHaskell", Opt_TemplateHaskell, const Supported ),
+ ( "QuasiQuotes", Opt_QuasiQuotes, const Supported ),
+ ( "Generics", Opt_Generics, const Supported ),
-- On by default:
- ( "ImplicitPrelude", Opt_ImplicitPrelude ),
- ( "RecordWildCards", Opt_RecordWildCards ),
- ( "RecordPuns", Opt_RecordPuns ),
- ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields ),
- ( "OverloadedStrings", Opt_OverloadedStrings ),
- ( "GADTs", Opt_GADTs ),
- ( "ViewPatterns", Opt_ViewPatterns),
- ( "TypeFamilies", Opt_TypeFamilies ),
- ( "BangPatterns", Opt_BangPatterns ),
+ ( "ImplicitPrelude", Opt_ImplicitPrelude, const Supported ),
+ ( "RecordWildCards", Opt_RecordWildCards, const Supported ),
+ ( "NamedFieldPuns", Opt_RecordPuns, const Supported ),
+ ( "RecordPuns", Opt_RecordPuns,
+ deprecatedForLanguage "NamedFieldPuns" ),
+ ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields, const Supported ),
+ ( "OverloadedStrings", Opt_OverloadedStrings, const Supported ),
+ ( "GADTs", Opt_GADTs, const Supported ),
+ ( "ViewPatterns", Opt_ViewPatterns, const Supported ),
+ ( "TypeFamilies", Opt_TypeFamilies, const Supported ),
+ ( "BangPatterns", Opt_BangPatterns, const Supported ),
-- On by default:
- ( "MonomorphismRestriction", Opt_MonomorphismRestriction ),
+ ( "MonomorphismRestriction", Opt_MonomorphismRestriction, const Supported ),
-- On by default (which is not strictly H98):
- ( "MonoPatBinds", Opt_MonoPatBinds ),
- ( "RelaxedPolyRec", Opt_RelaxedPolyRec),
- ( "ExtendedDefaultRules", Opt_ExtendedDefaultRules ),
- ( "ImplicitParams", Opt_ImplicitParams ),
- ( "ScopedTypeVariables", Opt_ScopedTypeVariables ),
- ( "UnboxedTuples", Opt_UnboxedTuples ),
- ( "StandaloneDeriving", Opt_StandaloneDeriving ),
- ( "DeriveDataTypeable", Opt_DeriveDataTypeable ),
- ( "TypeSynonymInstances", Opt_TypeSynonymInstances ),
- ( "FlexibleContexts", Opt_FlexibleContexts ),
- ( "FlexibleInstances", Opt_FlexibleInstances ),
- ( "ConstrainedClassMethods", Opt_ConstrainedClassMethods ),
- ( "MultiParamTypeClasses", Opt_MultiParamTypeClasses ),
- ( "FunctionalDependencies", Opt_FunctionalDependencies ),
- ( "GeneralizedNewtypeDeriving", Opt_GeneralizedNewtypeDeriving ),
- ( "OverlappingInstances", Opt_OverlappingInstances ),
- ( "UndecidableInstances", Opt_UndecidableInstances ),
- ( "IncoherentInstances", Opt_IncoherentInstances )
+ ( "MonoPatBinds", Opt_MonoPatBinds, const Supported ),
+ ( "RelaxedPolyRec", Opt_RelaxedPolyRec, const Supported ),
+ ( "ExtendedDefaultRules", Opt_ExtendedDefaultRules, const Supported ),
+ ( "ImplicitParams", Opt_ImplicitParams, const Supported ),
+ ( "ScopedTypeVariables", Opt_ScopedTypeVariables, const Supported ),
+ ( "UnboxedTuples", Opt_UnboxedTuples, const Supported ),
+ ( "StandaloneDeriving", Opt_StandaloneDeriving, const Supported ),
+ ( "DeriveDataTypeable", Opt_DeriveDataTypeable, const Supported ),
+ ( "TypeSynonymInstances", Opt_TypeSynonymInstances, const Supported ),
+ ( "FlexibleContexts", Opt_FlexibleContexts, const Supported ),
+ ( "FlexibleInstances", Opt_FlexibleInstances, const Supported ),
+ ( "ConstrainedClassMethods", Opt_ConstrainedClassMethods, const Supported ),
+ ( "MultiParamTypeClasses", Opt_MultiParamTypeClasses, const Supported ),
+ ( "FunctionalDependencies", Opt_FunctionalDependencies, const Supported ),
+ ( "GeneralizedNewtypeDeriving", Opt_GeneralizedNewtypeDeriving, const Supported ),
+ ( "OverlappingInstances", Opt_OverlappingInstances, const Supported ),
+ ( "UndecidableInstances", Opt_UndecidableInstances, const Supported ),
+ ( "IncoherentInstances", Opt_IncoherentInstances, const Supported )
]
impliedFlags :: [(DynFlag, [DynFlag])]
, Opt_PolymorphicComponents
, Opt_ExistentialQuantification
, Opt_UnicodeSyntax
+ , Opt_PostfixOperators
, Opt_PatternGuards
, Opt_LiberalTypeSynonyms
, Opt_RankNTypes
, Opt_GeneralizedNewtypeDeriving
, Opt_TypeFamilies ]
-------------------
-isFlag :: [(String,a)] -> String -> Bool
-isFlag flags f = any (\(ff,_) -> ff == f) flags
-
-isPrefFlag :: String -> [(String,a)] -> String -> Bool
-isPrefFlag pref flags no_f
- | Just f <- maybePrefixMatch pref no_f = isFlag flags f
- | otherwise = False
-
-------------------
-getFlag :: [(String,a)] -> String -> a
-getFlag flags f = case [ opt | (ff, opt) <- flags, ff == f] of
- (o:_) -> o
- [] -> panic ("get_flag " ++ f)
-
-getPrefFlag :: String -> [(String,a)] -> String -> a
-getPrefFlag pref flags f = getFlag flags (fromJust (maybePrefixMatch pref f))
--- We should only be passed flags which match the prefix
-
-- -----------------------------------------------------------------------------
-- Parsing the dynamic flags.
-parseDynamicFlags :: DynFlags -> [String] -> IO (DynFlags,[String])
+parseDynamicFlags :: DynFlags -> [String] -> IO (DynFlags, [String], [String])
parseDynamicFlags dflags args = do
- let ((leftover,errs),dflags')
- = runCmdLine (processArgs dynamic_flags args) dflags
+ -- XXX Legacy support code
+ -- We used to accept things like
+ -- optdep-f -optdepdepend
+ -- optdep-f -optdep depend
+ -- optdep -f -optdepdepend
+ -- optdep -f -optdep depend
+ -- but the spaces trip up proper argument handling. So get rid of them.
+ let f ("-optdep" : x : xs) = ("-optdep" ++ x) : f xs
+ f (x : xs) = x : f xs
+ f xs = xs
+ args' = f args
+ let ((leftover, errs, warns), dflags')
+ = runCmdLine (processArgs dynamic_flags args') dflags
when (not (null errs)) $ do
- throwDyn (UsageError (unlines errs))
- return (dflags', leftover)
-
+ ghcError (UsageError (unlines errs))
+ return (dflags', leftover, warns)
type DynP = CmdLineP DynFlags
setPackageName :: String -> DynFlags -> DynFlags
setPackageName p
| Nothing <- unpackPackageId pid
- = throwDyn (CmdLineError ("cannot parse \'" ++ p ++ "\' as a package identifier"))
+ = ghcError (CmdLineError ("cannot parse \'" ++ p ++ "\' as a package identifier"))
| otherwise
= \s -> s{ thisPackage = pid }
where
`dopt_set` Opt_DictsCheap
`dopt_unset` Opt_MethodSharing
+data DPHBackend = DPHPar
+ | DPHSeq
+
+setDPHBackend :: DPHBackend -> DynFlags -> DynFlags
+setDPHBackend backend dflags = dflags { dphBackend = backend }
setMainIs :: String -> DynP ()
sta = opt_Static
in
( [ if sta then "-DDONT_WANT_WIN32_DLL_SUPPORT" else ""
--- , if "mingw32" `isSuffixOf` cTARGETPLATFORM then "-mno-cygwin" else ""
],
[ "-fno-defer-pop",
"-fomit-frame-pointer",