X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Fmain%2FDynFlags.hs;h=ad327bda0fcd631b1c7907e46669369d574c1d8d;hp=a0519165ff8210a54ee64a48c30a83fbb6c8e48a;hb=cae75f82226638691cfa1e85fc168f4b65ddce4d;hpb=0079141c61f673039ccd879cd75174b33eb40b8f diff --git a/compiler/main/DynFlags.hs b/compiler/main/DynFlags.hs index a051916..ad327bd 100644 --- a/compiler/main/DynFlags.hs +++ b/compiler/main/DynFlags.hs @@ -23,6 +23,7 @@ module DynFlags ( Option(..), DynLibLoader(..), fFlags, xFlags, + DPHBackend(..), -- Configuration of the core-to-core and stg-to-stg phases CoreToDo(..), @@ -49,7 +50,7 @@ module DynFlags ( -- misc stuff machdepCCOpts, picCCOpts, - supportedLanguages, + supportedLanguages, languageOptions, compilerInfo, ) where @@ -71,7 +72,7 @@ import Constants ( mAX_CONTEXT_REDUCTION_DEPTH ) import Panic ( panic, GhcException(..) ) import UniqFM ( UniqFM ) import Util -import Maybes ( orElse, fromJust ) +import Maybes ( orElse ) import SrcLoc ( SrcSpan ) import Outputable import {-# SOURCE #-} ErrUtils ( Severity(..), Message, mkLocMessage ) @@ -82,7 +83,7 @@ import Control.Monad ( when ) import Data.Char import System.FilePath -import System.IO ( hPutStrLn, stderr ) +import System.IO ( stderr, hPutChar ) -- ----------------------------------------------------------------------------- -- DynFlags @@ -168,10 +169,12 @@ data DynFlag | Opt_WarnUnusedBinds | Opt_WarnUnusedImports | Opt_WarnUnusedMatches - | Opt_WarnDeprecations + | Opt_WarnWarningsDeprecations + | Opt_WarnDeprecatedFlags | Opt_WarnDodgyImports | Opt_WarnOrphans | Opt_WarnTabs + | Opt_WarnDodgyForeignImports -- language opts | Opt_OverlappingInstances @@ -219,6 +222,7 @@ data DynFlag | Opt_TransformListComp | Opt_GeneralizedNewtypeDeriving | Opt_RecursiveDo + | Opt_PostfixOperators | Opt_PatternGuards | Opt_LiberalTypeSynonyms | Opt_Rank2Types @@ -273,6 +277,7 @@ data DynFlag | Opt_EmbedManifest | Opt_RunCPSZ | Opt_ConvertToZipCfgAndBack + | Opt_AutoLinkPackages -- keeping stuff | Opt_KeepHiDiffs @@ -309,6 +314,8 @@ data DynFlags = DynFlags { mainFunIs :: Maybe String, ctxtStkDepth :: Int, -- Typechecker context stack depth + dphBackend :: DPHBackend, + thisPackage :: PackageId, -- ways @@ -500,6 +507,8 @@ defaultDynFlags = mainFunIs = Nothing, ctxtStkDepth = mAX_CONTEXT_REDUCTION_DEPTH, + dphBackend = DPHPar, + thisPackage = mainPackageId, objectDir = Nothing, @@ -562,6 +571,7 @@ defaultDynFlags = -- end of initSysTools values haddockOptions = Nothing, flags = [ + Opt_AutoLinkPackages, Opt_ReadUserPackageConf, Opt_MonoPatBinds, -- Experimentally, I'm making this non-standard @@ -585,9 +595,14 @@ defaultDynFlags = 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. } {- @@ -741,11 +756,13 @@ optLevelFlags standardWarnings :: [DynFlag] standardWarnings - = [ Opt_WarnDeprecations, + = [ Opt_WarnWarningsDeprecations, + Opt_WarnDeprecatedFlags, Opt_WarnOverlappingPatterns, Opt_WarnMissingFields, Opt_WarnMissingMethods, - Opt_WarnDuplicateExports + Opt_WarnDuplicateExports, + Opt_WarnDodgyForeignImports ] minusWOpts :: [DynFlag] @@ -805,7 +822,7 @@ data CoreToDo -- These are diff core-to-core passes, | 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 @@ -846,8 +863,7 @@ getCoreToDo dflags 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) @@ -859,6 +875,11 @@ getCoreToDo dflags 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 @@ -893,7 +914,7 @@ getCoreToDo dflags core_todo = if opt_level == 0 then - [runWhen vectorisation (CoreDoPasses [ simpl_gently, CoreDoVectorisation ]), + [vectorisation, simpl_phase 0 ["final"] max_iter] else {- opt_level >= 1 -} [ @@ -901,15 +922,14 @@ getCoreToDo dflags -- 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 @@ -1011,407 +1031,521 @@ allFlags = map ('-':) $ [ 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 "optdep" (HasArg (upd . addOptdep)) Supported + , Flag "optwindres" (HasArg (upd . addOptwindres)) Supported , Flag "split-objs" (NoArg (if can_split then setDynFlag Opt_SplitObjs else return ())) + Supported -------- 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) 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 flags can all be reversed with -fno- -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 ), + ( "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 flags can all be reversed with -XNo -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])] @@ -1443,6 +1577,7 @@ glasgowExtsFlags = [ , Opt_PolymorphicComponents , Opt_ExistentialQuantification , Opt_UnicodeSyntax + , Opt_PostfixOperators , Opt_PatternGuards , Opt_LiberalTypeSynonyms , Opt_RankNTypes @@ -1456,36 +1591,16 @@ glasgowExtsFlags = [ , 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') + let ((leftover, errs, warns), dflags') = runCmdLine (processArgs dynamic_flags args) dflags when (not (null errs)) $ do throwDyn (UsageError (unlines errs)) - return (dflags', leftover) - + return (dflags', leftover, warns) type DynP = CmdLineP DynFlags @@ -1628,6 +1743,11 @@ setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations = 20 `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 () @@ -1789,7 +1909,6 @@ machdepCCOpts _dflags 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",