allFlags,
-- misc stuff
- machdepCCOpts, picCCOpts
+ machdepCCOpts, picCCOpts,
+ supportedLanguages,
+ compilerInfo,
) where
#include "HsVersions.h"
import Constants ( mAX_CONTEXT_REDUCTION_DEPTH )
import Panic ( panic, GhcException(..) )
import UniqFM ( UniqFM )
-import Util ( notNull, splitLongestPrefix, normalisePath )
+import Util
import Maybes ( orElse, fromJust )
import SrcLoc ( SrcSpan )
import Outputable
= Opt_D_dump_cmm
| Opt_D_dump_cps_cmm
| Opt_D_dump_asm
+ | Opt_D_dump_asm_native
+ | Opt_D_dump_asm_liveness
+ | Opt_D_dump_asm_coalesce
+ | Opt_D_dump_asm_regalloc
+ | Opt_D_dump_asm_regalloc_stages
+ | Opt_D_dump_asm_conflicts
| Opt_D_dump_cpranal
| Opt_D_dump_deriv
| Opt_D_dump_ds
| Opt_WarnTabs
-- language opts
- | Opt_AllowOverlappingInstances
- | Opt_AllowUndecidableInstances
- | Opt_AllowIncoherentInstances
+ | Opt_OverlappingInstances
+ | Opt_UndecidableInstances
+ | Opt_IncoherentInstances
| Opt_MonomorphismRestriction
| Opt_MonoPatBinds
| Opt_ExtendedDefaultRules -- Use GHC's extended rules for defaulting
- | Opt_GlasgowExts
- | Opt_FFI
+ | Opt_ForeignFunctionInterface
+ | Opt_UnliftedFFITypes
| Opt_PArr -- Syntactic support for parallel arrays
| Opt_Arrows -- Arrow-notation syntax
- | Opt_TH
+ | Opt_TemplateHaskell
| Opt_ImplicitParams
| Opt_Generics
| Opt_ImplicitPrelude
| Opt_ScopedTypeVariables
+ | Opt_UnboxedTuples
| Opt_BangPatterns
| Opt_TypeFamilies
| Opt_OverloadedStrings
| Opt_RecordWildCards
| Opt_RecordPuns
| Opt_GADTs
- | Opt_RelaxedPolyRec -- -X=RelaxedPolyRec
+ | Opt_RelaxedPolyRec
+ | Opt_StandaloneDeriving
+ | Opt_DeriveDataTypeable
| Opt_TypeSynonymInstances
+ | Opt_FlexibleContexts
| Opt_FlexibleInstances
+ | Opt_ConstrainedClassMethods
| Opt_MultiParamTypeClasses
| Opt_FunctionalDependencies
+ | Opt_UnicodeSyntax
+ | Opt_PolymorphicComponents
+ | Opt_ExistentialQuantification
| Opt_MagicHash
| Opt_EmptyDataDecls
| Opt_KindSignatures
+ | Opt_PatternSignatures
| Opt_ParallelListComp
| Opt_GeneralizedNewtypeDeriving
| Opt_RecursiveDo
| Opt_PatternGuards
+ | Opt_PartiallyAppliedClosedTypeSynonyms
+ | Opt_Rank2Types
+ | Opt_RankNTypes
+ | Opt_TypeOperators
+
+ | Opt_PrintExplicitForalls
-- optimisation opts
| Opt_Strictness
| Opt_DictsCheap
| Opt_RewriteRules
| Opt_Vectorise
+ | Opt_RegsGraph
-- misc opts
| Opt_Cpp
Opt_WarnOrphans
]
+-- minuswRemovesOpts should be every warning option
+minuswRemovesOpts
+ = minusWallOpts ++
+ [Opt_WarnImplicitPrelude,
+ Opt_WarnIncompletePatternsRecUpd,
+ Opt_WarnSimplePatterns,
+ Opt_WarnMonomorphism,
+ Opt_WarnTabs
+ ]
+
-- -----------------------------------------------------------------------------
-- CoreToDo: abstraction of core-to-core passes to run.
| CoreCSE
| CoreDoRuleCheck Int{-CompilerPhase-} String -- Check for non-application of rules
-- matching this string
+ | CoreDoVectorisation
| 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
core_todo =
if opt_level == 0 then
MaxSimplifierIterations max_iter
],
+
+ -- We run vectorisation here for now, but we might also try to run
+ -- it later
+ runWhen vectorisation (CoreDoPasses [
+ CoreDoVectorisation,
+ CoreDoSimplify SimplGently
+ [NoCaseOfCase,
+ MaxSimplifierIterations max_iter]]),
+
-- Specialisation is best done before full laziness
-- so that overloaded functions have all their dictionary lambdas manifest
CoreDoSpecialising,
, ( "ddump-cmm", setDumpFlag Opt_D_dump_cmm)
, ( "ddump-cps-cmm", setDumpFlag Opt_D_dump_cps_cmm)
, ( "ddump-asm", setDumpFlag Opt_D_dump_asm)
+ , ( "ddump-asm-native", setDumpFlag Opt_D_dump_asm_native)
+ , ( "ddump-asm-liveness", setDumpFlag Opt_D_dump_asm_liveness)
+ , ( "ddump-asm-coalesce", setDumpFlag Opt_D_dump_asm_coalesce)
+ , ( "ddump-asm-regalloc", setDumpFlag Opt_D_dump_asm_regalloc)
+ , ( "ddump-asm-conflicts", setDumpFlag Opt_D_dump_asm_conflicts)
+ , ( "ddump-asm-regalloc-stages",
+ setDumpFlag Opt_D_dump_asm_regalloc_stages)
, ( "ddump-cpranal", setDumpFlag Opt_D_dump_cpranal)
, ( "ddump-deriv", setDumpFlag Opt_D_dump_deriv)
, ( "ddump-ds", setDumpFlag Opt_D_dump_ds)
, ( "Werror" , NoArg (setDynFlag Opt_WarnIsError) )
, ( "Wall" , NoArg (mapM_ setDynFlag minusWallOpts) )
, ( "Wnot" , NoArg (mapM_ unSetDynFlag minusWallOpts) ) /* DEPREC */
- , ( "w" , NoArg (mapM_ unSetDynFlag minusWallOpts) )
+ , ( "w" , NoArg (mapM_ unSetDynFlag minuswRemovesOpts) )
------ Optimisation flags ------------------------------------------
, ( "O" , NoArg (upd (setOptLevel 1)))
- , ( "Onot" , NoArg (upd (setOptLevel 0)))
+ , ( "Onot" , NoArg (upd (setOptLevel 0))) -- deprecated
, ( "O" , OptIntSuffix (\mb_n -> upd (setOptLevel (mb_n `orElse` 1))))
-- If the number is missing, use 1
------ Compiler flags -----------------------------------------------
- , ( "fasm", NoArg (setObjTarget HscAsm) )
- , ( "fvia-c", NoArg (setObjTarget HscC) )
- , ( "fvia-C", NoArg (setObjTarget HscC) )
+ , ( "fasm", NoArg (setObjTarget HscAsm) )
+ , ( "fvia-c", NoArg (setObjTarget HscC) )
+ , ( "fvia-C", NoArg (setObjTarget HscC) )
- , ( "fno-code", NoArg (setTarget HscNothing))
- , ( "fbyte-code", NoArg (setTarget HscInterpreted) )
- , ( "fobject-code", NoArg (setTarget defaultHscTarget) )
+ , ( "fno-code", NoArg (setTarget HscNothing))
+ , ( "fbyte-code", NoArg (setTarget HscInterpreted) )
+ , ( "fobject-code", NoArg (setTarget defaultHscTarget) )
, ( "fglasgow-exts", NoArg (mapM_ setDynFlag glasgowExtsFlags) )
, ( "fno-glasgow-exts", NoArg (mapM_ unSetDynFlag glasgowExtsFlags) )
- -- the rest of the -f* and -fno-* flags
- , ( "f", PrefixPred (isFlag fFlags) (\f -> setDynFlag (getFlag fFlags f)) )
- , ( "f", PrefixPred (isNoFlag fFlags) (\f -> unSetDynFlag (getNoFlag fFlags f)) )
-
- -- For now, allow -X flags with -f; ToDo: report this as deprecated
- , ( "f", PrefixPred (isFlag xFlags) (\f -> setDynFlag (getFlag xFlags f)) )
- , ( "f", PrefixPred (isNoFlag xFlags) (\f -> unSetDynFlag (getNoFlag xFlags f)) )
-
- -- the rest of the -X* and -Xno-* flags
- , ( "X", PrefixPred (isFlag xFlags) (\f -> setDynFlag (getFlag xFlags f)) )
- , ( "X", PrefixPred (isNoFlag xFlags) (\f -> unSetDynFlag (getNoFlag xFlags f)) )
+ -- the rest of the -f* and -fno-* flags
+ , ( "f", PrefixPred (isFlag fFlags)
+ (\f -> setDynFlag (getFlag fFlags f)) )
+ , ( "f", PrefixPred (isPrefFlag "no-" fFlags)
+ (\f -> unSetDynFlag (getPrefFlag "no-" fFlags f)) )
+
+ -- the -X* and -XNo* flags
+ , ( "X", PrefixPred (isFlag xFlags)
+ (\f -> setDynFlag (getFlag xFlags f)) )
+ , ( "X", PrefixPred (isPrefFlag "No" xFlags)
+ (\f -> unSetDynFlag (getPrefFlag "No" xFlags f)) )
]
-- these -f<blah> flags can all be reversed with -fno-<blah>
fFlags = [
- ( "warn-duplicate-exports", Opt_WarnDuplicateExports ),
- ( "warn-hi-shadowing", Opt_WarnHiShadows ),
+ ( "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 ),
- ( "strictness", Opt_Strictness ),
- ( "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 ),
+ ( "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 ),
+ ( "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 ),
( "ignore-breakpoints", Opt_IgnoreBreakpoints),
- ( "do-eta-reduction", Opt_DoEtaReduction ),
- ( "case-merge", Opt_CaseMerge ),
- ( "unbox-strict-fields", Opt_UnboxStrictFields ),
- ( "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 ),
+ ( "do-eta-reduction", Opt_DoEtaReduction ),
+ ( "case-merge", Opt_CaseMerge ),
+ ( "unbox-strict-fields", Opt_UnboxStrictFields ),
+ ( "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 ),
- ( "vectorise", Opt_Vectorise )
+ ( "vectorise", Opt_Vectorise ),
+ ( "regs-graph", Opt_RegsGraph),
+ -- 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 )
]
+supportedLanguages :: [String]
+supportedLanguages = map fst xFlags
--- These -X<blah> flags can all be reversed with -Xno-<blah>
+-- These -X<blah> flags can all be reversed with -XNo<blah>
xFlags :: [(String, DynFlag)]
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 ),
- ( "FI", Opt_FFI ), -- support `-ffi'...
- ( "FFI", Opt_FFI ), -- ...and also `-fffi'
- ( "ForeignFunctionInterface", Opt_FFI ),
-
+ ( "ForeignFunctionInterface", Opt_ForeignFunctionInterface ),
+ ( "UnliftedFFITypes", Opt_UnliftedFFITypes ),
+ ( "PartiallyAppliedClosedTypeSynonyms",
+ Opt_PartiallyAppliedClosedTypeSynonyms ),
+ ( "Rank2Types", Opt_Rank2Types ),
+ ( "RankNTypes", Opt_RankNTypes ),
+ ( "TypeOperators", Opt_TypeOperators ),
( "RecursiveDo", Opt_RecursiveDo ),
- ( "Arrows", Opt_Arrows ), -- arrow syntax
- ( "Parr", Opt_PArr ),
-
- ( "TH", Opt_TH ), -- support -fth
- ( "TemplateHaskelll", Opt_TH ),
-
- ( "Generics", Opt_Generics ),
-
- ( "ImplicitPrelude", Opt_ImplicitPrelude ), -- On by default
-
- ( "RecordWildCards", Opt_RecordWildCards ),
- ( "RecordPuns", Opt_RecordPuns ),
- ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields ),
-
- ( "OverloadedStrings", Opt_OverloadedStrings ),
- ( "GADTs", Opt_GADTs ),
- ( "TypeFamilies", Opt_TypeFamilies ),
- ( "BangPatterns", Opt_BangPatterns ),
- ( "MonomorphismRestriction", Opt_MonomorphismRestriction ), -- On by default
- ( "MonoPatBinds", Opt_MonoPatBinds ), -- On by default (which is not strictly H98)
- ( "RelaxedPolyRec", Opt_RelaxedPolyRec),
- ( "ExtendedDefaultRules", Opt_ExtendedDefaultRules ),
- ( "ImplicitParams", Opt_ImplicitParams ),
- ( "ScopedTypeVariables", Opt_ScopedTypeVariables ),
- ( "TypeSynonymInstances", Opt_TypeSynonymInstances ),
- ( "FlexibleInstances", Opt_FlexibleInstances ),
- ( "MultiParamTypeClasses", Opt_MultiParamTypeClasses ),
- ( "FunctionalDependencies", Opt_FunctionalDependencies ),
- ( "GeneralizedNewtypeDeriving", Opt_GeneralizedNewtypeDeriving ),
- ( "AllowOverlappingInstances", Opt_AllowOverlappingInstances ),
- ( "AllowUndecidableInstances", Opt_AllowUndecidableInstances ),
- ( "AllowIncoherentInstances", Opt_AllowIncoherentInstances )
+ ( "Arrows", Opt_Arrows ),
+ ( "PArr", Opt_PArr ),
+ ( "TemplateHaskell", Opt_TemplateHaskell ),
+ ( "Generics", Opt_Generics ),
+ -- On by default:
+ ( "ImplicitPrelude", Opt_ImplicitPrelude ),
+ ( "RecordWildCards", Opt_RecordWildCards ),
+ ( "RecordPuns", Opt_RecordPuns ),
+ ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields ),
+ ( "OverloadedStrings", Opt_OverloadedStrings ),
+ ( "GADTs", Opt_GADTs ),
+ ( "TypeFamilies", Opt_TypeFamilies ),
+ ( "BangPatterns", Opt_BangPatterns ),
+ -- On by default:
+ ( "MonomorphismRestriction", Opt_MonomorphismRestriction ),
+ -- 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 )
]
impliedFlags :: [(DynFlag, [DynFlag])]
( Opt_GADTs, [Opt_RelaxedPolyRec] ) -- We want type-sig variables to be completely rigid for GADTs
]
-glasgowExtsFlags = [ Opt_GlasgowExts
- , Opt_FFI
+glasgowExtsFlags = [
+ Opt_PrintExplicitForalls
+ , Opt_ForeignFunctionInterface
+ , Opt_UnliftedFFITypes
, Opt_GADTs
, Opt_ImplicitParams
, Opt_ScopedTypeVariables
+ , Opt_UnboxedTuples
, Opt_TypeSynonymInstances
+ , Opt_StandaloneDeriving
+ , Opt_DeriveDataTypeable
+ , Opt_FlexibleContexts
, Opt_FlexibleInstances
+ , Opt_ConstrainedClassMethods
, Opt_MultiParamTypeClasses
, Opt_FunctionalDependencies
, Opt_MagicHash
+ , Opt_PolymorphicComponents
+ , Opt_ExistentialQuantification
+ , Opt_UnicodeSyntax
, Opt_PatternGuards
+ , Opt_PartiallyAppliedClosedTypeSynonyms
+ , Opt_RankNTypes
+ , Opt_TypeOperators
, Opt_RecursiveDo
, Opt_ParallelListComp
, Opt_EmptyDataDecls
, Opt_KindSignatures
+ , Opt_PatternSignatures
, Opt_GeneralizedNewtypeDeriving
, Opt_TypeFamilies ]
------------------
-isNoFlag, isFlag :: [(String,a)] -> String -> Bool
-
-isFlag flags f = is_flag flags (normaliseFlag f)
+isFlag :: [(String,a)] -> String -> Bool
+isFlag flags f = any (\(ff,_) -> ff == f) flags
-isNoFlag flags no_f
- | Just f <- noFlag_maybe (normaliseFlag no_f) = is_flag flags f
- | otherwise = False
-
-is_flag flags nf = any (\(ff,_) -> normaliseFlag ff == nf) flags
- -- nf is normalised alreadly
+isPrefFlag :: String -> [(String,a)] -> String -> Bool
+isPrefFlag pref flags no_f
+ | Just f <- maybePrefixMatch pref no_f = isFlag flags f
+ | otherwise = False
------------------
-getFlag, getNoFlag :: [(String,a)] -> String -> a
-
-getFlag flags f = get_flag flags (normaliseFlag f)
-
-getNoFlag flags f = get_flag flags (fromJust (noFlag_maybe (normaliseFlag f)))
- -- The flag should be a no-flag already
+getFlag :: [(String,a)] -> String -> a
+getFlag flags f = case [ opt | (ff, opt) <- flags, ff == f] of
+ (o:os) -> o
+ [] -> panic ("get_flag " ++ f)
-get_flag flags nf = case [ opt | (ff, opt) <- flags, normaliseFlag ff == nf] of
- (o:os) -> o
- [] -> panic ("get_flag " ++ nf)
-
-------------------
-noFlag_maybe :: String -> Maybe String
--- The input is normalised already
-noFlag_maybe ('n' : 'o' : f) = Just f
-noFlag_maybe other = Nothing
-
-normaliseFlag :: String -> String
--- Normalise a option flag by
--- * map to lower case
--- * removing hyphens
--- Thus: -X=overloaded-strings or -XOverloadedStrings
-normaliseFlag [] = []
-normaliseFlag ('-':s) = normaliseFlag s
-normaliseFlag (c:s) = toLower c : normaliseFlag s
+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.
-- Splitting
can_split :: Bool
-can_split =
-#if defined(i386_TARGET_ARCH) \
- || defined(x86_64_TARGET_ARCH) \
- || defined(alpha_TARGET_ARCH) \
- || defined(hppa_TARGET_ARCH) \
- || defined(m68k_TARGET_ARCH) \
- || defined(mips_TARGET_ARCH) \
- || defined(powerpc_TARGET_ARCH) \
- || defined(rs6000_TARGET_ARCH) \
- || defined(sparc_TARGET_ARCH)
- True
-#else
- False
-#endif
+can_split = cSplitObjs == "YES"
+
+-- -----------------------------------------------------------------------------
+-- Compiler Info
+
+compilerInfo :: [(String, String)]
+compilerInfo = [("Project name", cProjectName),
+ ("Project version", cProjectVersion),
+ ("Booter version", cBooterVersion),
+ ("Stage", cStage),
+ ("Interface file version", cHscIfaceFileVersion),
+ ("Object splitting", cSplitObjs),
+ ("Have native code generator", cGhcWithNativeCodeGen),
+ ("Unregisterised", cGhcUnregisterised),
+ ("Tables next to code", cGhcEnableTablesNextToCode),
+ ("Win32 DLLs", cEnableWin32DLLs),
+ ("Leading underscore", cLeadingUnderscore)]