{-# LANGUAGE CPP #-}
{-# OPTIONS_GHC -Wno-missing-fields -Wno-name-shadowing -Wno-unused-imports #-}

-- | Settings needed for running the GHC Parser.
module Exon.Haskell.Settings (baseDynFlags) where

import Data.Data hiding (Fixity)
import Data.Maybe
import GHC.Data.FastString
import GHC.Data.StringBuffer
import GHC.Driver.Backpack.Syntax
import GHC.Driver.Config
import GHC.Driver.Session
import GHC.Hs
import qualified GHC.Parser as Parser
import GHC.Parser.Lexer
import qualified GHC.Parser.Lexer as Lexer
import GHC.Parser.PostProcess
import GHC.Platform
import GHC.Settings
import GHC.Settings.Config
import GHC.Types.Fixity
import GHC.Types.Name
import GHC.Types.Name.Reader
import GHC.Types.SourceText
import GHC.Types.SrcLoc
import GHC.Unit.Info
import GHC.Utils.Fingerprint
import qualified Language.Haskell.TH.Syntax as GhcTH

fakeSettings :: Settings
fakeSettings :: Settings
fakeSettings = Settings
  { sGhcNameVersion :: GhcNameVersion
sGhcNameVersion=GhcNameVersion
ghcNameVersion
  , sFileSettings :: FileSettings
sFileSettings=FileSettings
fileSettings
  , sTargetPlatform :: Platform
sTargetPlatform=Platform
platform
  , sPlatformMisc :: PlatformMisc
sPlatformMisc=PlatformMisc
platformMisc
  , sToolSettings :: ToolSettings
sToolSettings=ToolSettings
toolSettings
  }
  where
    toolSettings :: ToolSettings
toolSettings = ToolSettings {
      toolSettings_opt_P_fingerprint :: Fingerprint
toolSettings_opt_P_fingerprint=Fingerprint
fingerprint0
      }
    fileSettings :: FileSettings
fileSettings = FileSettings {}
    platformMisc :: PlatformMisc
platformMisc = PlatformMisc {}
    ghcNameVersion :: GhcNameVersion
ghcNameVersion =
      GhcNameVersion{ghcNameVersion_programName :: String
ghcNameVersion_programName=String
"ghc"
                    ,ghcNameVersion_projectVersion :: String
ghcNameVersion_projectVersion=String
cProjectVersion
                    }
    platform :: Platform
platform =
      Platform{
    -- It doesn't matter what values we write here as these fields are
    -- not referenced for our purposes. However the fields are strict
    -- so we must say something.
        platformByteOrder :: ByteOrder
platformByteOrder=ByteOrder
LittleEndian
      , platformHasGnuNonexecStack :: Bool
platformHasGnuNonexecStack=Bool
True
      , platformHasIdentDirective :: Bool
platformHasIdentDirective=Bool
False
      , platformHasSubsectionsViaSymbols :: Bool
platformHasSubsectionsViaSymbols=Bool
False
      , platformIsCrossCompiling :: Bool
platformIsCrossCompiling=Bool
False
      , platformLeadingUnderscore :: Bool
platformLeadingUnderscore=Bool
False
      , platformTablesNextToCode :: Bool
platformTablesNextToCode=Bool
False
      , platform_constants :: Maybe PlatformConstants
platform_constants=Maybe PlatformConstants
forall {a}. Maybe a
platformConstants
      ,

        platformWordSize :: PlatformWordSize
platformWordSize=PlatformWordSize
PW8
      , platformArchOS :: ArchOS
platformArchOS=ArchOS {archOS_arch :: Arch
archOS_arch=Arch
ArchUnknown, archOS_OS :: OS
archOS_OS=OS
OSUnknown}

#if MIN_VERSION_ghc(9, 4, 0)
      , platformHasLibm :: Bool
platformHasLibm = Bool
False
#endif
      , platformUnregisterised :: Bool
platformUnregisterised=Bool
True
      }
    platformConstants :: Maybe a
platformConstants = Maybe a
forall {a}. Maybe a
Nothing

#if MIN_VERSION_ghc(9, 6, 0)
applyFakeLlvmConfig :: a -> a
applyFakeLlvmConfig = id
#else
applyFakeLlvmConfig :: (LlvmConfig -> a) -> a
applyFakeLlvmConfig :: forall a. (LlvmConfig -> a) -> a
applyFakeLlvmConfig LlvmConfig -> a
f = LlvmConfig -> a
f (LlvmConfig -> a) -> LlvmConfig -> a
forall a b. (a -> b) -> a -> b
$ [(String, LlvmTarget)] -> [(Int, String)] -> LlvmConfig
LlvmConfig [] []
#endif

baseDynFlags :: [GhcTH.Extension] -> DynFlags
baseDynFlags :: [Extension] -> DynFlags
baseDynFlags [Extension]
exts =
  let enable :: [Extension]
enable = Extension
GhcTH.TemplateHaskellQuotes Extension -> [Extension] -> [Extension]
forall a. a -> [a] -> [a]
: [Extension]
exts
   in (DynFlags -> Extension -> DynFlags)
-> DynFlags -> [Extension] -> DynFlags
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl DynFlags -> Extension -> DynFlags
xopt_set ((LlvmConfig -> DynFlags) -> DynFlags
forall a. (LlvmConfig -> a) -> a
applyFakeLlvmConfig (Settings -> LlvmConfig -> DynFlags
defaultDynFlags Settings
fakeSettings)) [Extension]
enable