Setup.hs for base

{-
We need to do some ugly hacks here as base mix of portable and
unportable stuff, as well as home to some GHC magic.
-}

module Main (main) where

import Data.List
import Distribution.Simple
import Distribution.PackageDescription
import Distribution.PreProcess
import Distribution.Setup
import Distribution.Simple.LocalBuildInfo
import System.Environment

main :: IO ()
main = do args <- getArgs
          let (ghcArgs, args') = extractGhcArgs args
          let hooks = defaultUserHooks {
                  buildHook = add_ghc_options ghcArgs
                            $ filter_modules_hook
                            $ buildHook defaultUserHooks,
                  instHook = filter_modules_hook $ instHook defaultUserHooks }
          withArgs args' $ defaultMainWithHooks hooks

extractGhcArgs :: [String] -> ([String], [String])
extractGhcArgs args
 = let f [] = ([], [])
       f (x:xs) = case f xs of
                      (ghcArgs, otherArgs) ->
                          case removePrefix "--ghc-option=" x of
                              Just ghcArg ->
                                  (ghcArg:ghcArgs, otherArgs)
                              Nothing ->
                                  (ghcArgs, x:otherArgs)
   in f args

removePrefix :: String -> String -> Maybe String
removePrefix "" ys = Just ys
removePrefix (x:xs) (y:ys)
 | x == y = removePrefix xs ys
 | otherwise = Nothing

type Hook a = PackageDescription -> LocalBuildInfo -> Maybe UserHooks -> a
           -> IO ()

add_ghc_options :: [String] -> Hook a -> Hook a
add_ghc_options args f pd lbi muhs x
 = do let lib' = case library pd of
                     Just lib ->
                         let bi = libBuildInfo lib
                             opts = options bi ++ [(GHC, args)]
                             bi' = bi { options = opts }
                         in lib { libBuildInfo = bi' }
                     Nothing -> error "Expected a library"
          pd' = pd { library = Just lib' }
      f pd' lbi muhs x

filter_modules_hook :: Hook a -> Hook a
filter_modules_hook f pd lbi muhs x
 = let build_filter = case compilerFlavor $ compiler lbi of
                          GHC -> forGHCBuild
                          _ -> isPortableBuild
       lib' = case library pd of
                  Just lib ->
                      let ems = filter build_filter (exposedModules lib)
                      in lib { exposedModules = ems }
                  Nothing -> error "Expected a library"
       pd' = pd { library = Just lib' }
   in f pd' lbi muhs x

isPortableBuild :: String -> Bool
isPortableBuild s
 | "GHC" `isPrefixOf` s = False
 | "Data.Generics" `isPrefixOf` s = False
 | otherwise = s `elem` ["Control.Parallel.Strategies",
                         "Foreign.Concurrent",
                         "System.Process"]

forGHCBuild :: String -> Bool
forGHCBuild = ("GHC.Prim" /=)

name:		base
version:	2.0
license:	BSD3
license-file:	LICENSE
maintainer:	[email protected]
synopsis:	Basic libraries
description:
	This package contains the Prelude and its support libraries,
	and a large collection of useful libraries ranging from data
	structures to parsing combinators and debugging utilities.
exposed-modules:
	Control.Applicative,
	Control.Arrow,
	Control.Concurrent,
	Control.Concurrent.Chan,
	Control.Concurrent.MVar,
	Control.Concurrent.QSem,
	Control.Concurrent.QSemN,
	Control.Concurrent.SampleVar,
	Control.Exception,
	Control.Monad,
	Control.Monad.Fix,
	Control.Monad.Instances,
	Control.Monad.ST,
	Control.Monad.ST.Lazy,
	Control.Monad.ST.Strict,
	Control.Parallel,
	Control.Parallel.Strategies,
	Data.Array,
	Data.Array.Base,
	Data.Array.Diff,
	Data.Array.IArray,
	Data.Array.IO,
	Data.Array.IO.Internals,
	Data.Array.MArray,
	Data.Array.ST,
	Data.Array.Storable,
	Data.Array.Unboxed,
	Data.Bits,
	Data.Bool,
	Data.ByteString,
	Data.ByteString.Char8,
    Data.ByteString.Lazy
    Data.ByteString.Lazy.Char8
    Data.ByteString.Base
    Data.ByteString.Fusion
	Data.Char,
	Data.Complex,
	Data.Dynamic,
	Data.Either,
	Data.Eq,
	Data.Foldable,
	Data.Fixed,
	Data.FunctorM,
	Data.Generics,
	Data.Generics.Aliases,
	Data.Generics.Basics,
	Data.Generics.Instances,
	Data.Generics.Schemes,
	Data.Generics.Text,
	Data.Generics.Twins,
	Data.Graph,
	Data.HashTable,
	Data.IORef,
	Data.Int,
	Data.IntMap,
	Data.IntSet,
	Data.Ix,
	Data.List,
	Data.Maybe,
	Data.Map,
	Data.Monoid,
	Data.Ord,
	Data.PackedString,
	Data.Queue,
	Data.Ratio,
	Data.STRef,
	Data.STRef.Lazy,
	Data.STRef.Strict,
	Data.Sequence,
	Data.Set,
	Data.Tree,
	Data.Traversable,
	Data.Tuple,
	Data.Typeable,
	Data.Unique,
	Data.Version,
	Data.Word,
	Debug.Trace,
	Foreign,
	Foreign.C,
	Foreign.C.Error,
	Foreign.C.String,
	Foreign.C.Types,
	Foreign.Concurrent,
	Foreign.ForeignPtr,
	Foreign.Marshal,
	Foreign.Marshal.Alloc,
	Foreign.Marshal.Array,
	Foreign.Marshal.Error,
	Foreign.Marshal.Pool,
	Foreign.Marshal.Utils,
	Foreign.Ptr,
	Foreign.StablePtr,
	Foreign.Storable,
	GHC.Arr,
	GHC.Base,
	GHC.Conc,
	GHC.ConsoleHandler,
	GHC.Dotnet,
	GHC.Dynamic,
	GHC.Enum,
	GHC.Err,
	GHC.Exception,
	GHC.Exts,
	GHC.Float,
	GHC.ForeignPtr,
	GHC.Handle,
	GHC.IO,
	GHC.IOBase,
	GHC.Int,
	GHC.List,
	GHC.Num,
	GHC.PArr,
	GHC.Pack,
	GHC.Prim,
	GHC.PrimopWrappers,
	GHC.Ptr,
	GHC.Read,
	GHC.Real,
	GHC.ST,
	GHC.STRef,
	GHC.Show,
	GHC.Stable,
	GHC.Storable,
	GHC.TopHandler,
	GHC.Unicode,
	GHC.Weak,
	GHC.Word,
	Numeric,
	Prelude,
	System.Cmd,
	System.Console.GetOpt,
	System.CPUTime,
	System.Directory,
	System.Directory.Internals,
	System.Environment,
	System.Exit,
	System.IO,
	System.IO.Error,
	System.IO.Unsafe,
	System.Info,
	System.Locale,
	System.Mem,
	System.Mem.StableName,
	System.Mem.Weak,
	System.Posix.Internals,
	System.Posix.Signals,
	System.Posix.Types,
	System.Process,
	System.Process.Internals,
	System.Random,
	System.Time,
	Text.ParserCombinators.ReadP,
	Text.ParserCombinators.ReadPrec,
	Text.PrettyPrint,
	Text.PrettyPrint.HughesPJ,
	Text.Printf,
	Text.Read,
	Text.Read.Lex,
	Text.Show,
	Text.Show.Functions
include-dirs:	include, ../../ghc/includes
includes:	HsBase.h
extensions:	CPP