Constant-fold `__GLASGOW_HASKELL__` CPP conditionals
authorHerbert Valerio Riedel <hvr@gnu.org>
Sun, 15 Sep 2013 21:05:05 +0000 (23:05 +0200)
committerHerbert Valerio Riedel <hvr@gnu.org>
Tue, 17 Sep 2013 07:54:07 +0000 (09:54 +0200)
Now that HUGS and NHC specific code has been removed, this commit "folds"
the now redundant `#if((n)def)`s containing `__GLASGOW_HASKELL__`.  This
renders `base` officially GHC only.

This commit also removes redundant `{-# LANGUAGE CPP #-}`.

Signed-off-by: Herbert Valerio Riedel <hvr@gnu.org>
101 files changed:
Control/Applicative.hs
Control/Category.hs
Control/Concurrent.hs
Control/Concurrent/Chan.hs
Control/Concurrent/MVar.hs
Control/Concurrent/QSem.hs
Control/Concurrent/QSemN.hs
Control/Exception.hs
Control/Exception/Base.hs
Control/Monad.hs
Control/Monad/Fix.hs
Control/Monad/ST/Imp.hs
Control/Monad/ST/Lazy/Imp.hs
Data/Bits.hs
Data/Bool.hs
Data/Char.hs
Data/Complex.hs
Data/Data.hs
Data/Dynamic.hs
Data/Either.hs
Data/Eq.hs
Data/Fixed.hs
Data/Foldable.hs
Data/Functor.hs
Data/IORef.hs
Data/Int.hs
Data/Ix.hs
Data/List.hs
Data/Maybe.hs
Data/Monoid.hs
Data/OldTypeable.hs
Data/OldTypeable/Internal.hs
Data/Ord.hs
Data/Proxy.hs
Data/Ratio.hs
Data/STRef.hs
Data/String.hs
Data/Traversable.hs
Data/Tuple.hs
Data/Typeable.hs
Data/Typeable/Internal.hs
Data/Unique.hs
Data/Version.hs
Data/Word.hs
Debug/Trace.hs
Foreign/C/Error.hs
Foreign/C/String.hs
Foreign/C/Types.hs
Foreign/Concurrent.hs
Foreign/ForeignPtr.hs
Foreign/ForeignPtr/Imp.hs
Foreign/ForeignPtr/Safe.hs
Foreign/ForeignPtr/Unsafe.hs
Foreign/Marshal.hs
Foreign/Marshal/Alloc.hs
Foreign/Marshal/Array.hs
Foreign/Marshal/Error.hs
Foreign/Marshal/Pool.hs
Foreign/Marshal/Safe.hs
Foreign/Marshal/Unsafe.hs
Foreign/Marshal/Utils.hs
Foreign/Ptr.hs
Foreign/StablePtr.hs
Foreign/Storable.hs
GHC/Constants.hs
GHC/Desugar.hs
GHC/Err.lhs
GHC/Foreign.hs
GHC/IO/Device.hs
GHC/IO/Encoding/UTF16.hs
GHC/Read.lhs
Numeric.hs
Prelude.hs
System/CPUTime.hsc
System/Environment.hs
System/Exit.hs
System/IO.hs
System/IO/Error.hs
System/IO/Unsafe.hs
System/Info.hs
System/Mem.hs
System/Mem/StableName.hs
System/Mem/Weak.hs
System/Posix/Internals.hs
System/Posix/Types.hs
System/Timeout.hs
Text/ParserCombinators/ReadP.hs
Text/ParserCombinators/ReadPrec.hs
Text/Printf.hs
Text/Read.hs
Text/Read/Lex.hs
Text/Show.hs
Text/Show/Functions.hs
Unsafe/Coerce.hs
include/CTypes.h
include/HsBase.h
include/OldTypeable.h
include/Typeable.h
tests/IO/hSeek001.hs
tests/qsem001.hs
tests/qsemn001.hs

index 9f6b514..e1ad80a 100644 (file)
@@ -1,5 +1,4 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -59,9 +58,7 @@ import Data.Proxy
 import Text.ParserCombinators.ReadP (ReadP)
 import Text.ParserCombinators.ReadPrec (ReadPrec)
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Conc (STM, retry, orElse)
-#endif
 
 infixl 3 <|>
 infixl 4 <*>, <*, *>, <**>
@@ -181,7 +178,6 @@ instance Applicative (Lazy.ST s) where
     pure = return
     (<*>) = ap
 
-#ifdef __GLASGOW_HASKELL__
 instance Applicative STM where
     pure = return
     (<*>) = ap
@@ -189,7 +185,6 @@ instance Applicative STM where
 instance Alternative STM where
     empty = retry
     (<|>) = orElse
-#endif
 
 instance Applicative ((->) a) where
     pure = const
index 9eaf38f..76ade1d 100644 (file)
 module Control.Category where
 
 import qualified Prelude
-
-#ifdef __GLASGOW_HASKELL__
 import Data.Type.Equality
-#endif
 
 infixr 9 .
 infixr 1 >>>, <<<
@@ -50,11 +47,9 @@ instance Category (->) where
     id = Prelude.id
     (.) = (Prelude..)
 
-#ifdef __GLASGOW_HASKELL__
 instance Category (:=:) where
   id          = Refl
   Refl . Refl = Refl
-#endif
 
 -- | Right-to-left composition
 (<<<) :: Category cat => cat b c -> cat a b -> cat a c
index 09674f7..4251ef1 100644 (file)
@@ -33,17 +33,13 @@ module Control.Concurrent (
         -- * Basic concurrency operations
 
         ThreadId,
-#ifdef __GLASGOW_HASKELL__
         myThreadId,
-#endif
 
         forkIO,
-#ifdef __GLASGOW_HASKELL__
         forkFinally,
         forkIOWithUnmask,
         killThread,
         throwTo,
-#endif
 
         -- ** Threads with affinity
         forkOn,
@@ -61,14 +57,12 @@ module Control.Concurrent (
 
         -- $blocking
 
-#ifdef __GLASGOW_HASKELL__
         -- ** Waiting
         threadDelay,
         threadWaitRead,
         threadWaitWrite,
         threadWaitReadSTM,
         threadWaitWriteSTM,
-#endif
 
         -- * Communication abstractions
 
@@ -77,7 +71,6 @@ module Control.Concurrent (
         module Control.Concurrent.QSem,
         module Control.Concurrent.QSemN,
 
-#ifdef __GLASGOW_HASKELL__
         -- * Bound Threads
         -- $boundthreads
         rtsSupportsBoundThreads,
@@ -85,7 +78,6 @@ module Control.Concurrent (
         isCurrentThreadBound,
         runInBoundThread,
         runInUnboundThread,
-#endif
 
         -- * Weak references to ThreadIds
         mkWeakThreadId,
@@ -117,7 +109,6 @@ import Prelude
 
 import Control.Exception.Base as Exception
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Exception
 import GHC.Conc hiding (threadWaitRead, threadWaitWrite,
                         threadWaitReadSTM, threadWaitWriteSTM)
@@ -136,7 +127,6 @@ import Foreign.C
 import System.IO
 import Data.Maybe (Maybe(..))
 #endif
-#endif
 
 import Control.Concurrent.MVar
 import Control.Concurrent.Chan
@@ -211,7 +201,6 @@ forkFinally action and_then =
   mask $ \restore ->
     forkIO $ try (restore action) >>= and_then
 
-#ifdef __GLASGOW_HASKELL__
 -- ---------------------------------------------------------------------------
 -- Bound Threads
 
@@ -396,9 +385,7 @@ runInUnboundThread action = do
 
 unsafeResult :: Either SomeException a -> IO a
 unsafeResult = either Exception.throwIO return
-#endif /* __GLASGOW_HASKELL__ */
 
-#ifdef __GLASGOW_HASKELL__
 -- ---------------------------------------------------------------------------
 -- threadWaitRead/threadWaitWrite
 
@@ -672,5 +659,3 @@ alternative then it is possible to prevent the thread from being
 considered deadlocked by making a 'StablePtr' pointing to it.  Don't
 forget to release the 'StablePtr' later with 'freeStablePtr'.
 -}
-
-#endif /* __GLASGOW_HASKELL__ */
index ca4c17c..0efc172 100644 (file)
@@ -1,8 +1,6 @@
 {-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
-#ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
-#endif
 
 -----------------------------------------------------------------------------
 -- |
index e8b2ce5..c9ed3e1 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude, UnboxedTuples, MagicHash #-}
+{-# LANGUAGE NoImplicitPrelude, UnboxedTuples, MagicHash #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -146,20 +146,13 @@ module Control.Concurrent.MVar
         , addMVarFinalizer
     ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.MVar ( MVar(..), newEmptyMVar, newMVar, takeMVar, putMVar,
                   tryTakeMVar, tryPutMVar, isEmptyMVar, readMVar,
                   tryReadMVar
                 )
 import qualified GHC.MVar
 import GHC.Weak
-#endif
-
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
-#else
-import Prelude
-#endif
 
 import Control.Exception.Base
 
index 1751a29..2761ef2 100644 (file)
@@ -1,8 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP #-}
-#ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, BangPatterns #-}
-#endif
 {-# OPTIONS_GHC -funbox-strict-fields #-}
 
 -----------------------------------------------------------------------------
index f0db152..546b8f9 100644 (file)
@@ -1,8 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP #-}
-#ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, BangPatterns #-}
-#endif
 {-# OPTIONS_GHC -funbox-strict-fields #-}
 
 -----------------------------------------------------------------------------
index 36a8efe..49a39c0 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude, ExistentialQuantification #-}
+{-# LANGUAGE NoImplicitPrelude, ExistentialQuantification #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -44,11 +44,8 @@ module Control.Exception (
         AsyncException(..),     -- instance Eq, Ord, Show, Typeable, Exception
         asyncExceptionToException, asyncExceptionFromException,
 
-#if __GLASGOW_HASKELL__
         NonTermination(..),
         NestedAtomically(..),
-#endif
-
         BlockedIndefinitelyOnMVar(..),
         BlockedIndefinitelyOnSTM(..),
         Deadlock(..),
@@ -63,9 +60,7 @@ module Control.Exception (
         throw,
         throwIO,
         ioError,
-#ifdef __GLASGOW_HASKELL__
         throwTo,
-#endif
 
         -- * Catching Exceptions
 
@@ -136,13 +131,9 @@ module Control.Exception (
 
 import Control.Exception.Base
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.IO (unsafeUnmask)
 import Data.Maybe
-#else
-import Prelude hiding (catch)
-#endif
 
 -- | You need this when using 'catches'.
 data Handler a = forall e . Exception e => Handler (e -> IO a)
index a16ce8e..8ff5482 100644 (file)
@@ -1,8 +1,6 @@
 {-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, MagicHash #-}
-#ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
-#endif
 
 #include "Typeable.h"
 
@@ -31,12 +29,8 @@ module Control.Exception.Base (
         AssertionFailed(..),
         SomeAsyncException(..), AsyncException(..),
         asyncExceptionToException, asyncExceptionFromException,
-
-#ifdef __GLASGOW_HASKELL__
         NonTermination(..),
         NestedAtomically(..),
-#endif
-
         BlockedIndefinitelyOnMVar(..),
         BlockedIndefinitelyOnSTM(..),
         Deadlock(..),
@@ -51,9 +45,7 @@ module Control.Exception.Base (
         throwIO,
         throw,
         ioError,
-#ifdef __GLASGOW_HASKELL__
         throwTo,
-#endif
 
         -- * Catching Exceptions
 
@@ -98,16 +90,13 @@ module Control.Exception.Base (
 
         finally,
 
-#ifdef __GLASGOW_HASKELL__
         -- * Calls for GHC runtime
         recSelError, recConError, irrefutPatError, runtimeError,
         nonExhaustiveGuardsError, patError, noMethodBindingError,
         absentError,
         nonTermination, nestedAtomically,
-#endif
   ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.IO hiding (bracket,finally,onException)
 import GHC.IO.Exception
@@ -115,7 +104,6 @@ import GHC.Exception
 import GHC.Show
 -- import GHC.Exception hiding ( Exception )
 import GHC.Conc.Sync
-#endif
 
 import Data.Dynamic
 import Data.Either
@@ -161,9 +149,7 @@ catch   :: Exception e
         => IO a         -- ^ The computation to run
         -> (e -> IO a)  -- ^ Handler to invoke if an exception is raised
         -> IO a
-#if __GLASGOW_HASKELL__
 catch = catchException
-#endif
 
 -- | The function 'catchJust' is like 'catch', but it takes an extra
 -- argument which is an /exception predicate/, a function which
@@ -309,15 +295,8 @@ bracketOnError before after thing =
     a <- before
     restore (thing a) `onException` after a
 
-#if !__GLASGOW_HASKELL__
-assert :: Bool -> a -> a
-assert True x = x
-assert False _ = throw (AssertionFailed "")
-#endif
-
 -----
 
-#if __GLASGOW_HASKELL__
 -- |A pattern match failed. The @String@ gives information about the
 -- source location of the pattern.
 data PatternMatchFail = PatternMatchFail String
@@ -412,9 +391,6 @@ instance Exception NestedAtomically
 
 -----
 
-#endif /* __GLASGOW_HASKELL__ */
-
-#ifdef __GLASGOW_HASKELL__
 recSelError, recConError, irrefutPatError, runtimeError,
   nonExhaustiveGuardsError, patError, noMethodBindingError,
   absentError
@@ -438,4 +414,3 @@ nonTermination = toException NonTermination
 -- GHC's RTS calls this
 nestedAtomically :: SomeException
 nestedAtomically = toException NestedAtomically
-#endif
index 1aa1738..19c9a87 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -78,12 +78,9 @@ module Control.Monad
 
 import Data.Maybe
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.List
 import GHC.Base
-#endif
 
-#ifdef __GLASGOW_HASKELL__
 infixr 1 =<<
 
 -- -----------------------------------------------------------------------------
@@ -118,8 +115,6 @@ mapM_           :: Monad m => (a -> m b) -> [a] -> m ()
 {-# INLINE mapM_ #-}
 mapM_ f as      =  sequence_ (map f as)
 
-#endif  /* __GLASGOW_HASKELL__ */
-
 -- -----------------------------------------------------------------------------
 -- The MonadPlus class definition
 
index fb43b91..8036fef 100644 (file)
@@ -1,5 +1,4 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -26,9 +25,7 @@ module Control.Monad.Fix (
 import Prelude
 import System.IO
 import Data.Function (fix)
-#if defined(__GLASGOW_HASKELL__)
 import GHC.ST
-#endif
 
 -- | Monads having fixed points with a \'knot-tying\' semantics.
 -- Instances of 'MonadFix' should satisfy the following laws:
@@ -78,8 +75,5 @@ instance MonadFix (Either e) where
              where unRight (Right x) = x
                    unRight (Left  _) = error "mfix Either: Left"
 
-#if defined(__GLASGOW_HASKELL__)
 instance MonadFix (ST s) where
         mfix = fixST
-#endif
-
index 4876028..1df8628 100644 (file)
@@ -35,21 +35,8 @@ module Control.Monad.ST.Imp (
         unsafeSTToIO
     ) where
 
-#if !defined(__GLASGOW_HASKELL__)
-import Control.Monad.Fix
-#endif
-
 #include "Typeable.h"
 
-#if defined(__GLASGOW_HASKELL__)
 import GHC.ST           ( ST, runST, fixST, unsafeInterleaveST )
 import GHC.Base         ( RealWorld )
 import GHC.IO           ( stToIO, unsafeIOToST, unsafeSTToIO )
-#endif
-
-#if !defined(__GLASGOW_HASKELL__)
-instance MonadFix (ST s) where
-        mfix = fixST
-#endif
-
-
index d5e4695..40f5267 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Unsafe #-}
-{-# LANGUAGE CPP, MagicHash, UnboxedTuples, RankNTypes #-}
+{-# LANGUAGE MagicHash, UnboxedTuples, RankNTypes #-}
 {-# OPTIONS_HADDOCK hide #-}
 
 -----------------------------------------------------------------------------
@@ -44,12 +44,9 @@ import Control.Monad.Fix
 import qualified Control.Monad.ST.Safe as ST
 import qualified Control.Monad.ST.Unsafe as ST
 
-#ifdef __GLASGOW_HASKELL__
 import qualified GHC.ST as GHC.ST
 import GHC.Base
-#endif
 
-#ifdef __GLASGOW_HASKELL__
 -- | The lazy state-transformer monad.
 -- A computation of type @'ST' s a@ transforms an internal state indexed
 -- by @s@, and returns a value of type @a@.
@@ -107,7 +104,6 @@ fixST m = ST (\ s ->
                    (r,s') = m_r s
                 in
                    (r,s'))
-#endif
 
 instance MonadFix (ST s) where
         mfix = fixST
@@ -115,7 +111,6 @@ instance MonadFix (ST s) where
 -- ---------------------------------------------------------------------------
 -- Strict <--> Lazy
 
-#ifdef __GLASGOW_HASKELL__
 {-|
 Convert a strict 'ST' computation into a lazy one.  The strict state
 thread passed to 'strictToLazyST' is not performed until the result of
@@ -136,7 +131,6 @@ Convert a lazy 'ST' computation into a strict one.
 lazyToStrictST :: ST s a -> ST.ST s a
 lazyToStrictST (ST m) = GHC.ST.ST $ \s ->
         case (m (S# s)) of (a, S# s') -> (# s', a #)
-#endif
 
 -- | A monad transformer embedding lazy state transformers in the 'IO'
 -- monad.  The 'RealWorld' parameter indicates that the internal state
@@ -148,10 +142,8 @@ stToIO = ST.stToIO . lazyToStrictST
 -- ---------------------------------------------------------------------------
 -- Strict <--> Lazy
 
-#ifdef __GLASGOW_HASKELL__
 unsafeInterleaveST :: ST s a -> ST s a
 unsafeInterleaveST = strictToLazyST . ST.unsafeInterleaveST . lazyToStrictST
-#endif
 
 unsafeIOToST :: IO a -> ST s a
 unsafeIOToST = strictToLazyST . ST.unsafeIOToST
index 2d13b8b..e2eb3fe 100644 (file)
@@ -49,16 +49,12 @@ module Data.Bits (
 -- See library document for details on the semantics of the
 -- individual operations.
 
-#ifdef __GLASGOW_HASKELL__
 #include "MachDeps.h"
-#endif
 
-#ifdef __GLASGOW_HASKELL__
 import Data.Maybe
 import GHC.Enum
 import GHC.Num
 import GHC.Base
-#endif
 
 infixl 8 `shift`, `rotate`, `shiftL`, `shiftR`, `rotateL`, `rotateR`
 infixl 7 .&.
@@ -280,7 +276,6 @@ instance Bits Int where
     {-# INLINE bit #-}
     {-# INLINE testBit #-}
 
-#ifdef __GLASGOW_HASKELL__
     bit     = bitDefault
 
     testBit = testBitDefault
@@ -314,26 +309,11 @@ instance Bits Int where
 
     popCount (I# x#) = I# (word2Int# (popCnt# (int2Word# x#)))
 
-#else /* !__GLASGOW_HASKELL__ */
-
-    popCount               = popCountDefault
-
-    x `rotate`  i
-        | i<0 && x<0       = let left = i+bitSize x in
-                             ((x `shift` i) .&. complement ((-1) `shift` left))
-                             .|. (x `shift` left)
-        | i<0              = (x `shift` i) .|. (x `shift` (i+bitSize x))
-        | i==0             = x
-        | i>0              = (x `shift` i) .|. (x `shift` (i-bitSize x))
-
-#endif /* !__GLASGOW_HASKELL__ */
-
     isSigned _             = True
 
 instance FiniteBits Int where
     finiteBitSize _ = WORD_SIZE_IN_BITS
 
-#if defined(__GLASGOW_HASKELL__)
 instance Bits Word where
     {-# INLINE shift #-}
     {-# INLINE bit #-}
@@ -366,10 +346,8 @@ instance Bits Word where
 
 instance FiniteBits Word where
     finiteBitSize _ = WORD_SIZE_IN_BITS
-#endif
 
 instance Bits Integer where
-#if defined(__GLASGOW_HASKELL__)
    (.&.) = andInteger
    (.|.) = orInteger
    xor = xorInteger
@@ -377,26 +355,6 @@ instance Bits Integer where
    shift x i@(I# i#) | i >= 0    = shiftLInteger x i#
                      | otherwise = shiftRInteger x (negateInt# i#)
    testBit x (I# i) = testBitInteger x i
-#else
-   -- reduce bitwise binary operations to special cases we can handle
-
-   x .&. y   | x<0 && y<0 = complement (complement x `posOr` complement y)
-             | otherwise  = x `posAnd` y
-   
-   x .|. y   | x<0 || y<0 = complement (complement x `posAnd` complement y)
-             | otherwise  = x `posOr` y
-   
-   x `xor` y | x<0 && y<0 = complement x `posXOr` complement y
-             | x<0        = complement (complement x `posXOr` y)
-             |        y<0 = complement (x `posXOr` complement y)
-             | otherwise  = x `posXOr` y
-
-   -- assuming infinite 2's-complement arithmetic
-   complement a = -1 - a
-   shift x i | i >= 0    = x * 2^i
-             | otherwise = x `div` 2^(-i)
-   testBit    = testBitDefault
-#endif
 
    bit        = bitDefault
    popCount   = popCountDefault
@@ -407,38 +365,6 @@ instance Bits Integer where
    bitSize _  = error "Data.Bits.bitSize(Integer)"
    isSigned _ = True
 
-#if !defined(__GLASGOW_HASKELL__)
--- Crude implementation of bitwise operations on Integers: convert them
--- to finite lists of Ints (least significant first), zip and convert
--- back again.
-
--- posAnd requires at least one argument non-negative
--- posOr and posXOr require both arguments non-negative
-
-posAnd, posOr, posXOr :: Integer -> Integer -> Integer
-posAnd x y   = fromInts $ zipWith (.&.) (toInts x) (toInts y)
-posOr x y    = fromInts $ longZipWith (.|.) (toInts x) (toInts y)
-posXOr x y   = fromInts $ longZipWith xor (toInts x) (toInts y)
-
-longZipWith :: (a -> a -> a) -> [a] -> [a] -> [a]
-longZipWith f xs [] = xs
-longZipWith f [] ys = ys
-longZipWith f (x:xs) (y:ys) = f x y:longZipWith f xs ys
-
-toInts :: Integer -> [Int]
-toInts n
-    | n == 0 = []
-    | otherwise = mkInt (n `mod` numInts):toInts (n `div` numInts)
-  where mkInt n | n > toInteger(maxBound::Int) = fromInteger (n-numInts)
-                | otherwise = fromInteger n
-
-fromInts :: [Int] -> Integer
-fromInts = foldr catInt 0
-    where catInt d n = (if d<0 then n+1 else n)*numInts + toInteger d
-
-numInts = toInteger (maxBound::Int) - toInteger (minBound::Int) + 1
-#endif /* !__GLASGOW_HASKELL__ */
-
 {-     Note [Constant folding for rotate]
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 The INLINE on the Int instance of rotate enables it to be constant
index 9f6ce04..0dd8198 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -26,9 +26,7 @@ module Data.Bool (
    bool,
   ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
-#endif
 
 -- | Case analysis for the 'Bool' type.
 -- @bool a b p@ evaluates to @a@ when @p@ is @False@, and evaluates to @b@
index ad38c12..aa4a594 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -52,7 +52,6 @@ module Data.Char
     , readLitChar
     ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.Arr (Ix)
 import GHC.Char
@@ -62,7 +61,6 @@ import GHC.Read (Read, readLitChar, lexLitChar)
 import GHC.Unicode
 import GHC.Num
 import GHC.Enum
-#endif
 
 -- | Convert a single digit 'Char' to the corresponding 'Int'.  
 -- This function fails unless its argument satisfies 'isHexDigit',
@@ -75,12 +73,6 @@ digitToInt c
  | c >= 'A' && c <= 'F' =  ord c - ord 'A' + 10
  | otherwise            =  error ("Char.digitToInt: not a digit " ++ show c) -- sigh
 
-#ifndef __GLASGOW_HASKELL__
-isAsciiUpper, isAsciiLower :: Char -> Bool
-isAsciiLower c          =  c >= 'a' && c <= 'z'
-isAsciiUpper c          =  c >= 'A' && c <= 'Z'
-#endif
-
 -- | Unicode General Categories (column 2 of the UnicodeData table)
 -- in the order they are listed in the Unicode standard.
 
@@ -119,9 +111,7 @@ data GeneralCategory
 
 -- | The Unicode general category of the character.
 generalCategory :: Char -> GeneralCategory
-#if defined(__GLASGOW_HASKELL__)
 generalCategory c = toEnum $ fromIntegral $ wgencat $ fromIntegral $ ord c
-#endif
 
 -- derived character classifiers
 
index 95bb9a2..c852df9 100644 (file)
@@ -1,8 +1,6 @@
 {-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, DeriveDataTypeable #-}
-#ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE StandaloneDeriving #-}
-#endif
 
 -----------------------------------------------------------------------------
 -- |
@@ -39,9 +37,7 @@ module Data.Complex
 import Prelude
 
 import Data.Typeable
-#ifdef __GLASGOW_HASKELL__
 import Data.Data (Data)
-#endif
 
 infix  6  :+
 
@@ -56,11 +52,7 @@ infix  6  :+
 data Complex a
   = !a :+ !a    -- ^ forms a complex number from its real and imaginary
                 -- rectangular components.
-# if __GLASGOW_HASKELL__
         deriving (Eq, Show, Read, Data)
-# else
-        deriving (Eq, Show, Read)
-# endif
 
 -- -----------------------------------------------------------------------------
 -- Functions over Complex
index 309b704..762d96b 100644 (file)
@@ -116,7 +116,6 @@ import Control.Monad
 -- Imports for the instances
 import Data.Int              -- So we can give Data instance for Int8, ...
 import Data.Word             -- So we can give Data instance for Word8, ...
-#ifdef __GLASGOW_HASKELL__
 import GHC.Real( Ratio(..) ) -- So we can give Data instance for Ratio
 --import GHC.IOBase            -- So we can give Data instance for IO, Handle
 import GHC.Ptr               -- So we can give Data instance for Ptr
@@ -125,12 +124,6 @@ import GHC.ForeignPtr        -- So we can give Data instance for ForeignPtr
 --import GHC.ST                -- So we can give Data instance for ST
 --import GHC.Conc              -- So we can give Data instance for MVar & Co.
 import GHC.Arr               -- So we can give Data instance for Array
-#else
-import Foreign.Ptr
-import Foreign.ForeignPtr
-import Data.Array
-import Data.Proxy
-#endif
 
 #include "Typeable.h"
 
index 4492dd3..ccf78f3 100644 (file)
@@ -1,8 +1,6 @@
 {-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude #-}
-#ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
-#endif
 
 -----------------------------------------------------------------------------
 -- |
@@ -49,11 +47,9 @@ import Data.Typeable
 import Data.Maybe
 import Unsafe.Coerce
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.Show
 import GHC.Exception
-#endif
 
 #include "Typeable.h"
 
@@ -84,12 +80,9 @@ instance Show Dynamic where
           showsPrec 0 t   . 
           showString ">>"
 
-#ifdef __GLASGOW_HASKELL__
 -- here so that it isn't an orphan:
 instance Exception Dynamic
-#endif
 
-#ifdef __GLASGOW_HASKELL__
 type Obj = Any
  -- Use GHC's primitive 'Any' type to hold the dynamically typed value.
  --
@@ -98,9 +91,6 @@ type Obj = Any
  -- when evaluating it, and this will go wrong if the object is really a 
  -- function.  Using Any forces GHC to use
  -- a fallback convention for evaluating it that works for all types.
-#else
-data Obj = Obj
-#endif
 
 -- | Converts an arbitrary value into an object of type 'Dynamic'.  
 --
index 166c4f2..ac8656e 100644 (file)
@@ -1,8 +1,6 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
-#ifdef __GLASGOW_HASKELL__
+{-# LANGUAGE NoImplicitPrelude #-}
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
-#endif
 
 -----------------------------------------------------------------------------
 -- |
@@ -30,15 +28,12 @@ module Data.Either (
 
 #include "Typeable.h"
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.Show
 import GHC.Read
-#endif
 
 import Data.Typeable
 
-#ifdef __GLASGOW_HASKELL__
 {-
 -- just for testing
 import Test.QuickCheck
@@ -72,7 +67,6 @@ instance Monad (Either e) where
 either                  :: (a -> c) -> (b -> c) -> Either a b -> c
 either f _ (Left x)     =  f x
 either _ g (Right y)    =  g y
-#endif  /* __GLASGOW_HASKELL__ */
 
 INSTANCE_TYPEABLE2(Either,eitherTc,"Either")
 
index 0c45c78..fe487bf 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -19,7 +19,4 @@ module Data.Eq (
    Eq(..),
  ) where
 
-#if __GLASGOW_HASKELL__
 import GHC.Base
-#endif
-
index 6ea9bcd..d027354 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, ScopedTypeVariables, PatternGuards #-}
+{-# LANGUAGE ScopedTypeVariables, PatternGuards #-}
 {-# OPTIONS -Wall -fno-warn-unused-binds #-}
 {-# LANGUAGE DeriveDataTypeable #-}
 
index 3bc5214..de6c056 100644 (file)
@@ -1,5 +1,4 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -69,10 +68,8 @@ import Data.Maybe (fromMaybe, listToMaybe)
 import Data.Monoid
 import Data.Proxy
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Exts (build)
 import GHC.Arr
-#endif
 
 -- | Data structures that can be folded.
 --
@@ -260,11 +257,7 @@ msum = foldr mplus mzero
 -- | List of elements of a structure.
 toList :: Foldable t => t a -> [a]
 {-# INLINE toList #-}
-#ifdef __GLASGOW_HASKELL__
 toList t = build (\ c n -> foldr c n t)
-#else
-toList = foldr (:) []
-#endif
 
 -- | The concatenation of all the elements of a container of lists.
 concat :: Foldable t => t [a] -> [a]
index bac1464..a578bdd 100644 (file)
@@ -1,5 +1,4 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -24,16 +23,7 @@ module Data.Functor
     ) where
 
 import Control.Monad
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base (Functor(..))
-#endif
-
-#ifndef __GLASGOW_HASKELL__
-infixl 4 <$
-
-(<$) :: Functor f => a -> f b -> f a
-(<$) =  fmap . const
-#endif
 
 infixl 4 <$>
 
index 131c73a..f4eb9ec 100644 (file)
@@ -28,7 +28,7 @@ module Data.IORef
         atomicModifyIORef',
         atomicWriteIORef,
 
-#if !defined(__PARALLEL_HASKELL__) && defined(__GLASGOW_HASKELL__)
+#if !defined(__PARALLEL_HASKELL__)
         mkWeakIORef,
 #endif
         -- ** Memory Model
@@ -37,7 +37,6 @@ module Data.IORef
 
         ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.STRef
 import GHC.IORef hiding (atomicModifyIORef)
@@ -45,9 +44,8 @@ import qualified GHC.IORef
 #if !defined(__PARALLEL_HASKELL__)
 import GHC.Weak
 #endif
-#endif /* __GLASGOW_HASKELL__ */
 
-#if defined(__GLASGOW_HASKELL__) && !defined(__PARALLEL_HASKELL__)
+#if !defined(__PARALLEL_HASKELL__)
 -- |Make a 'Weak' pointer to an 'IORef', using the second argument as a finalizer
 -- to run when 'IORef' is garbage-collected
 mkWeakIORef :: IORef a -> IO () -> IO (Weak (IORef a))
@@ -98,9 +96,7 @@ modifyIORef' ref f = do
 -- Use 'atomicModifyIORef'' or 'atomicWriteIORef' to avoid this problem.
 --
 atomicModifyIORef :: IORef a -> (a -> (a,b)) -> IO b
-#ifdef __GLASGOW_HASKELL__
 atomicModifyIORef = GHC.IORef.atomicModifyIORef
-#endif
 
 -- | Strict version of 'atomicModifyIORef'.  This forces both the value stored
 -- in the 'IORef' as well as the value returned.
index 810bd32..8ca8221 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -26,10 +26,8 @@ module Data.Int
         -- $notes
         ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base ( Int )
 import GHC.Int  ( Int8, Int16, Int32, Int64 )
-#endif
 
 {- $notes
 
index 2eb42c1..bdfea60 100644 (file)
@@ -1,5 +1,4 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -64,6 +63,4 @@ module Data.Ix
 
 -- import Prelude
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Arr
-#endif
index e7e8602..7998976 100644 (file)
@@ -208,12 +208,10 @@ module Data.List
 import Data.Maybe
 import Data.Char        ( isSpace )
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Num
 import GHC.Real
 import GHC.List
 import GHC.Base
-#endif
 
 infix 5 \\ -- comment to fool cpp
 
@@ -270,8 +268,7 @@ findIndex p     = listToMaybe . findIndices p
 -- | The 'findIndices' function extends 'findIndex', by returning the
 -- indices of all elements satisfying the predicate, in ascending order.
 findIndices      :: (a -> Bool) -> [a] -> [Int]
-
-#if defined(USE_REPORT_PRELUDE) || !defined(__GLASGOW_HASKELL__)
+#ifdef USE_REPORT_PRELUDE
 findIndices p xs = [ i | (x,i) <- zip xs [0..], p x]
 #else
 -- Efficient definition
@@ -516,8 +513,6 @@ insertBy cmp x ys@(y:ys')
      GT -> y : insertBy cmp x ys'
      _  -> x : ys
 
-#ifdef __GLASGOW_HASKELL__
-
 -- | 'maximum' returns the maximum value from a list,
 -- which must be non-empty, finite, and of an ordered type.
 -- It is a special case of 'Data.List.maximumBy', which allows the
@@ -557,8 +552,6 @@ strictMinimum           :: (Ord a) => [a] -> a
 strictMinimum []        =  errorEmptyList "minimum"
 strictMinimum xs        =  foldl1' min xs
 
-#endif /* __GLASGOW_HASKELL__ */
-
 -- | The 'maximumBy' function takes a comparison function and a list
 -- and returns the greatest element of the list by the comparison function.
 -- The list must be finite and non-empty.
@@ -996,29 +989,21 @@ unfoldr f b  =
 
 -- | A strict version of 'foldl'.
 foldl'           :: (b -> a -> b) -> b -> [a] -> b
-#ifdef __GLASGOW_HASKELL__
 foldl' f z0 xs0 = lgo z0 xs0
     where lgo z []     = z
           lgo z (x:xs) = let z' = f z x in z' `seq` lgo z' xs
-#else
-foldl' f a []     = a
-foldl' f a (x:xs) = let a' = f a x in a' `seq` foldl' f a' xs
-#endif
 
-#ifdef __GLASGOW_HASKELL__
 -- | 'foldl1' is a variant of 'foldl' that has no starting value argument,
 -- and thus must be applied to non-empty lists.
 foldl1                  :: (a -> a -> a) -> [a] -> a
 foldl1 f (x:xs)         =  foldl f x xs
 foldl1 _ []             =  errorEmptyList "foldl1"
-#endif /* __GLASGOW_HASKELL__ */
 
 -- | A strict version of 'foldl1'
 foldl1'                  :: (a -> a -> a) -> [a] -> a
 foldl1' f (x:xs)         =  foldl' f x xs
 foldl1' _ []             =  errorEmptyList "foldl1'"
 
-#ifdef __GLASGOW_HASKELL__
 -- -----------------------------------------------------------------------------
 -- List sum and product
 
@@ -1056,7 +1041,6 @@ product l       = prod l 1
 -- characters.  The resulting strings do not contain newlines.
 lines                   :: String -> [String]
 lines ""                =  []
-#ifdef __GLASGOW_HASKELL__
 -- Somehow GHC doesn't detect the selector thunks in the below code,
 -- so s' keeps a reference to the first line via the pair and we have
 -- a space leak (cf. #4334).
@@ -1067,12 +1051,6 @@ lines s                 =  cons (case break (== '\n') s of
                                                     _:s''   -> lines s''))
   where
     cons ~(h, t)        =  h : t
-#else
-lines s                 =  let (l, s') = break (== '\n') s
-                           in  l : case s' of
-                                        []      -> []
-                                        (_:s'') -> lines s''
-#endif
 
 -- | 'unlines' is an inverse operation to 'lines'.
 -- It joins lines, after appending a terminating newline to each.
@@ -1108,12 +1086,3 @@ unwords []              =  ""
 unwords [w]             = w
 unwords (w:ws)          = w ++ ' ' : unwords ws
 #endif
-
-#else  /* !__GLASGOW_HASKELL__ */
-
-errorEmptyList :: String -> a
-errorEmptyList fun =
-  error ("Prelude." ++ fun ++ ": empty list")
-
-#endif /* !__GLASGOW_HASKELL__ */
-
index 05e6a87..245e307 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -31,9 +31,7 @@ module Data.Maybe
    , mapMaybe
    ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
-#endif
 
 -- ---------------------------------------------------------------------------
 -- The Maybe type, and instances
index 90bd437..1a17a32 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -36,16 +36,12 @@ module Data.Monoid (
   ) where
 
 -- Push down the module in the dependency hierarchy.
-#if defined(__GLASGOW_HASKELL__)
 import GHC.Base hiding (Any)
 import GHC.Enum
 import GHC.Num
 import GHC.Read
 import GHC.Show
 import Data.Maybe
-#else
-import Prelude
-#endif
 
 {-
 -- just for testing
index 3690f97..ab936c4 100644 (file)
@@ -95,14 +95,11 @@ import Data.OldTypeable.Internal hiding (mkTyCon)
 import Unsafe.Coerce
 import Data.Maybe
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 
 import GHC.Fingerprint.Type
 import GHC.Fingerprint
 
-#endif
-
 #include "OldTypeable.h"
 
 {-# DEPRECATED typeRepKey "TypeRep itself is now an instance of Ord" #-} -- deprecated in 7.2
index 305a57f..9718237 100644 (file)
            , OverlappingInstances
            , ScopedTypeVariables
            , FlexibleInstances
-           , MagicHash #-}
-#ifdef __GLASGOW_HASKELL__
-{-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
-#endif
+           , MagicHash
+           , DeriveDataTypeable
+           , StandaloneDeriving #-}
 
 module Data.OldTypeable.Internal {-# DEPRECATED "Use Data.Typeable.Internal instead" #-} ( -- deprecated in 7.8
     TypeRep(..),
@@ -51,9 +50,7 @@ module Data.OldTypeable.Internal {-# DEPRECATED "Use Data.Typeable.Internal inst
     typeRepArgs,
     showsTypeRep,
     tyConString,
-#if defined(__GLASGOW_HASKELL__)
     listTc, funTc
-#endif
   ) where
 
 import GHC.Base
@@ -223,7 +220,6 @@ class Typeable a where
 class Typeable1 t where
   typeOf1 :: t a -> TypeRep
 
-#ifdef __GLASGOW_HASKELL__
 -- | For defining a 'Typeable' instance from any 'Typeable1' instance.
 typeOfDefault :: forall t a. (Typeable1 t, Typeable a) => t a -> TypeRep
 typeOfDefault = \_ -> rep
@@ -231,20 +227,11 @@ typeOfDefault = \_ -> rep
    rep = typeOf1 (undefined :: t a) `mkAppTy` 
          typeOf  (undefined :: a)
    -- Note [Memoising typeOf]
-#else
--- | For defining a 'Typeable' instance from any 'Typeable1' instance.
-typeOfDefault :: (Typeable1 t, Typeable a) => t a -> TypeRep
-typeOfDefault x = typeOf1 x `mkAppTy` typeOf (argType x)
- where
-   argType :: t a -> a
-   argType = undefined
-#endif
 
 -- | Variant for binary type constructors
 class Typeable2 t where
   typeOf2 :: t a b -> TypeRep
 
-#ifdef __GLASGOW_HASKELL__
 -- | For defining a 'Typeable1' instance from any 'Typeable2' instance.
 typeOf1Default :: forall t a b. (Typeable2 t, Typeable a) => t a b -> TypeRep
 typeOf1Default = \_ -> rep 
@@ -252,20 +239,11 @@ typeOf1Default = \_ -> rep
    rep = typeOf2 (undefined :: t a b) `mkAppTy` 
          typeOf  (undefined :: a)
    -- Note [Memoising typeOf]
-#else
--- | For defining a 'Typeable1' instance from any 'Typeable2' instance.
-typeOf1Default :: (Typeable2 t, Typeable a) => t a b -> TypeRep
-typeOf1Default x = typeOf2 x `mkAppTy` typeOf (argType x)
- where
-   argType :: t a b -> a
-   argType = undefined
-#endif
 
 -- | Variant for 3-ary type constructors
 class Typeable3 t where
   typeOf3 :: t a b c -> TypeRep
 
-#ifdef __GLASGOW_HASKELL__
 -- | For defining a 'Typeable2' instance from any 'Typeable3' instance.
 typeOf2Default :: forall t a b c. (Typeable3 t, Typeable a) => t a b c -> TypeRep
 typeOf2Default = \_ -> rep 
@@ -273,20 +251,11 @@ typeOf2Default = \_ -> rep
    rep = typeOf3 (undefined :: t a b c) `mkAppTy` 
          typeOf  (undefined :: a)
    -- Note [Memoising typeOf]
-#else
--- | For defining a 'Typeable2' instance from any 'Typeable3' instance.
-typeOf2Default :: (Typeable3 t, Typeable a) => t a b c -> TypeRep
-typeOf2Default x = typeOf3 x `mkAppTy` typeOf (argType x)
- where
-   argType :: t a b c -> a
-   argType = undefined
-#endif
 
 -- | Variant for 4-ary type constructors
 class Typeable4 t where
   typeOf4 :: t a b c d -> TypeRep
 
-#ifdef __GLASGOW_HASKELL__
 -- | For defining a 'Typeable3' instance from any 'Typeable4' instance.
 typeOf3Default :: forall t a b c d. (Typeable4 t, Typeable a) => t a b c d -> TypeRep
 typeOf3Default = \_ -> rep
@@ -294,20 +263,11 @@ typeOf3Default = \_ -> rep
    rep = typeOf4 (undefined :: t a b c d) `mkAppTy` 
          typeOf  (undefined :: a)
    -- Note [Memoising typeOf]
-#else
--- | For defining a 'Typeable3' instance from any 'Typeable4' instance.
-typeOf3Default :: (Typeable4 t, Typeable a) => t a b c d -> TypeRep
-typeOf3Default x = typeOf4 x `mkAppTy` typeOf (argType x)
- where
-   argType :: t a b c d -> a
-   argType = undefined
-#endif
    
 -- | Variant for 5-ary type constructors
 class Typeable5 t where
   typeOf5 :: t a b c d e -> TypeRep
 
-#ifdef __GLASGOW_HASKELL__
 -- | For defining a 'Typeable4' instance from any 'Typeable5' instance.
 typeOf4Default :: forall t a b c d e. (Typeable5 t, Typeable a) => t a b c d e -> TypeRep
 typeOf4Default = \_ -> rep 
@@ -315,20 +275,11 @@ typeOf4Default = \_ -> rep
    rep = typeOf5 (undefined :: t a b c d e) `mkAppTy` 
          typeOf  (undefined :: a)
    -- Note [Memoising typeOf]
-#else
--- | For defining a 'Typeable4' instance from any 'Typeable5' instance.
-typeOf4Default :: (Typeable5 t, Typeable a) => t a b c d e -> TypeRep
-typeOf4Default x = typeOf5 x `mkAppTy` typeOf (argType x)
- where
-   argType :: t a b c d e -> a
-   argType = undefined
-#endif
 
 -- | Variant for 6-ary type constructors
 class Typeable6 t where
   typeOf6 :: t a b c d e f -> TypeRep
 
-#ifdef __GLASGOW_HASKELL__
 -- | For defining a 'Typeable5' instance from any 'Typeable6' instance.
 typeOf5Default :: forall t a b c d e f. (Typeable6 t, Typeable a) => t a b c d e f -> TypeRep
 typeOf5Default = \_ -> rep
@@ -336,20 +287,11 @@ typeOf5Default = \_ -> rep
    rep = typeOf6 (undefined :: t a b c d e f) `mkAppTy` 
          typeOf  (undefined :: a)
    -- Note [Memoising typeOf]
-#else
--- | For defining a 'Typeable5' instance from any 'Typeable6' instance.
-typeOf5Default :: (Typeable6 t, Typeable a) => t a b c d e f -> TypeRep
-typeOf5Default x = typeOf6 x `mkAppTy` typeOf (argType x)
- where
-   argType :: t a b c d e f -> a
-   argType = undefined
-#endif
 
 -- | Variant for 7-ary type constructors
 class Typeable7 t where
   typeOf7 :: t a b c d e f g -> TypeRep
 
-#ifdef __GLASGOW_HASKELL__
 -- | For defining a 'Typeable6' instance from any 'Typeable7' instance.
 typeOf6Default :: forall t a b c d e f g. (Typeable7 t, Typeable a) => t a b c d e f g -> TypeRep
 typeOf6Default = \_ -> rep
@@ -357,16 +299,7 @@ typeOf6Default = \_ -> rep
    rep = typeOf7 (undefined :: t a b c d e f g) `mkAppTy` 
          typeOf  (undefined :: a)
    -- Note [Memoising typeOf]
-#else
--- | For defining a 'Typeable6' instance from any 'Typeable7' instance.
-typeOf6Default :: (Typeable7 t, Typeable a) => t a b c d e f g -> TypeRep
-typeOf6Default x = typeOf7 x `mkAppTy` typeOf (argType x)
- where
-   argType :: t a b c d e f g -> a
-   argType = undefined
-#endif
 
-#ifdef __GLASGOW_HASKELL__
 -- Given a @Typeable@/n/ instance for an /n/-ary type constructor,
 -- define the instances for partial applications.
 -- Programmers using non-GHC implementations must do this manually
@@ -408,8 +341,6 @@ instance (Typeable7 s, Typeable a)
        => Typeable6 (s a) where
   typeOf6 = typeOf6Default
 
-#endif /* __GLASGOW_HASKELL__ */
-
 ----------------- Showing TypeReps --------------------
 
 instance Show TypeRep where
@@ -451,13 +382,11 @@ showTuple args = showChar '('
                                $ map (showsPrec 10) args)
                . showChar ')'
 
-#if defined(__GLASGOW_HASKELL__)
 listTc :: TyCon
 listTc = typeRepTyCon (typeOf [()])
 
 funTc :: TyCon
 funTc = mkTyCon3 "ghc-prim" "GHC.Types" "->"
-#endif
 
 -------------------------------------------------------------
 --
@@ -471,7 +400,7 @@ INSTANCE_TYPEABLE0((),unitTc,"()")
 INSTANCE_TYPEABLE1([],listTc,"[]")
 INSTANCE_TYPEABLE1(Maybe,maybeTc,"Maybe")
 INSTANCE_TYPEABLE1(Ratio,ratioTc,"Ratio")
-#if defined(__GLASGOW_HASKELL__)
+
 {-
 TODO: Deriving this instance fails with:
 libraries/base/Data/Typeable.hs:589:1:
@@ -480,24 +409,18 @@ libraries/base/Data/Typeable.hs:589:1:
     In the stand-alone deriving instance for `Typeable2 (->)'
 -}
 instance Typeable2 (->) where { typeOf2 _ = mkTyConApp funTc [] }
-#else
-INSTANCE_TYPEABLE2((->),funTc,"->")
-#endif
+
 INSTANCE_TYPEABLE1(IO,ioTc,"IO")
 
-#ifdef __GLASGOW_HASKELL__
 -- Types defined in GHC.MVar
 INSTANCE_TYPEABLE1(MVar,mvarTc,"MVar" )
-#endif
 
 INSTANCE_TYPEABLE2(Array,arrayTc,"Array")
 INSTANCE_TYPEABLE2(IOArray,iOArrayTc,"IOArray")
 
-#ifdef __GLASGOW_HASKELL__
 INSTANCE_TYPEABLE2(ST,stTc,"ST")
 INSTANCE_TYPEABLE2(STRef,stRefTc,"STRef")
 INSTANCE_TYPEABLE3(STArray,sTArrayTc,"STArray")
-#endif
 
 INSTANCE_TYPEABLE2((,),pairTc,"(,)")
 INSTANCE_TYPEABLE3((,,),tup3Tc,"(,,)")
@@ -508,9 +431,6 @@ INSTANCE_TYPEABLE7((,,,,,,),tup7Tc,"(,,,,,,)")
 
 INSTANCE_TYPEABLE1(Ptr,ptrTc,"Ptr")
 INSTANCE_TYPEABLE1(FunPtr,funPtrTc,"FunPtr")
-#ifndef __GLASGOW_HASKELL__
-INSTANCE_TYPEABLE1(ForeignPtr,foreignPtrTc,"ForeignPtr")
-#endif
 INSTANCE_TYPEABLE1(StablePtr,stablePtrTc,"StablePtr")
 INSTANCE_TYPEABLE1(IORef,iORefTc,"IORef")
 
@@ -528,9 +448,6 @@ INSTANCE_TYPEABLE0(Int,intTc,"Int")
 INSTANCE_TYPEABLE0(Word,wordTc,"Word" )
 INSTANCE_TYPEABLE0(Integer,integerTc,"Integer")
 INSTANCE_TYPEABLE0(Ordering,orderingTc,"Ordering")
-#ifndef __GLASGOW_HASKELL__
-INSTANCE_TYPEABLE0(Handle,handleTc,"Handle")
-#endif
 
 INSTANCE_TYPEABLE0(Int8,int8Tc,"Int8")
 INSTANCE_TYPEABLE0(Int16,int16Tc,"Int16")
@@ -545,7 +462,6 @@ INSTANCE_TYPEABLE0(Word64,word64Tc,"Word64")
 INSTANCE_TYPEABLE0(TyCon,tyconTc,"TyCon")
 INSTANCE_TYPEABLE0(TypeRep,typeRepTc,"TypeRep")
 
-#ifdef __GLASGOW_HASKELL__
 {-
 TODO: This can't be derived currently:
 libraries/base/Data/Typeable.hs:674:1:
@@ -556,5 +472,3 @@ libraries/base/Data/Typeable.hs:674:1:
 realWorldTc :: TyCon; \
 realWorldTc = mkTyCon3 "ghc-prim" "GHC.Types" "RealWorld"; \
 instance Typeable RealWorld where { typeOf _ = mkTyConApp realWorldTc [] }
-
-#endif
index c594c68..1748555 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -22,9 +22,7 @@ module Data.Ord (
    comparing,
  ) where
 
-#if __GLASGOW_HASKELL__
 import GHC.Base
-#endif
 
 -- | 
 -- > comparing p x y = compare (p x) (p y)
index bda295e..083db91 100644 (file)
@@ -1,7 +1,5 @@
 {-# LANGUAGE NoImplicitPrelude, Trustworthy #-}
-#ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE PolyKinds #-}
-#endif
 
 -----------------------------------------------------------------------------
 -- |
@@ -19,9 +17,7 @@
 module Data.Proxy
   (
         Proxy(..), asProxyTypeOf
-#ifdef __GLASGOW_HASKELL__
       , KProxy(..)
-#endif
   ) where
 
 import Data.Monoid
@@ -35,11 +31,9 @@ import GHC.Arr
 -- | A concrete, poly-kinded proxy type
 data Proxy t = Proxy
 
-#ifdef __GLASGOW_HASKELL__
 -- | A concrete, promotable proxy type, for use at the kind level
 -- There are no instances for this because it is intended at the kind level only
 data KProxy (t :: *) = KProxy
-#endif
 
 instance Eq (Proxy s) where
   _ == _ = True
@@ -69,10 +63,8 @@ instance Ix (Proxy s) where
     index _ _         = 0
     inRange _ _       = True
     rangeSize _       = 1
-#ifdef __GLASGOW_HASKELL__
     unsafeIndex _ _   = 0
     unsafeRangeSize _ = 1
-#endif
 
 instance Bounded (Proxy s) where
     minBound = Proxy
@@ -102,4 +94,4 @@ instance Monad Proxy where
 -- of the second.
 asProxyTypeOf :: a -> Proxy a -> a
 asProxyTypeOf = const
-{-# INLINE asProxyTypeOf #-}
\ No newline at end of file
+{-# INLINE asProxyTypeOf #-}
index 6af9088..6a16e9a 100644 (file)
@@ -1,5 +1,4 @@
 {-# LANGUAGE Safe #-}
-{-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -27,9 +26,7 @@ module Data.Ratio
 
 import Prelude
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Real         -- The basic defns for Ratio
-#endif
 
 -- -----------------------------------------------------------------------------
 -- approxRational
index ecedcc1..486cc4b 100644 (file)
@@ -1,5 +1,4 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -27,10 +26,8 @@ module Data.STRef (
 
 import Prelude
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.ST
 import GHC.STRef
-#endif
 
 -- | Mutate the contents of an 'STRef'.
 --
index 8c24fb9..a03569f 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude, FlexibleInstances #-}
+{-# LANGUAGE NoImplicitPrelude, FlexibleInstances #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -26,10 +26,7 @@ module Data.String (
  , unwords
  ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
-#endif
-
 import Data.List (lines, words, unlines, unwords)
 
 -- | Class for string-like datastructures; used by the overloaded string
index 9167331..7872a61 100644 (file)
@@ -1,5 +1,4 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -58,9 +57,7 @@ import Data.Foldable (Foldable())
 import Data.Monoid (Monoid)
 import Data.Proxy
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Arr
-#endif
 
 -- | Functors representing data structures that can be traversed from
 -- left to right.
index cc7ded3..ec8478a 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 {-# OPTIONS_GHC -fno-warn-unused-imports #-}
 -- XXX -fno-warn-unused-imports needed for the GHC.Tuple import below. Sigh.
 
@@ -26,8 +26,6 @@ module Data.Tuple
   )
     where
 
-#ifdef __GLASGOW_HASKELL__
-
 import GHC.Base
 -- We need to depend on GHC.Base so that
 -- a) so that we get GHC.Classes, GHC.Types
@@ -40,8 +38,6 @@ import GHC.Tuple
 -- data constructors of `(,)' are in scope when we do
 -- the standalone deriving instance for Eq (a,b) etc
 
-#endif  /* __GLASGOW_HASKELL__ */
-
 default ()              -- Double isn't available yet
 
 -- ---------------------------------------------------------------------------
index af8c672..355f17b 100644 (file)
@@ -1,6 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP
-           , NoImplicitPrelude
+{-# LANGUAGE NoImplicitPrelude
            , OverlappingInstances
            , ScopedTypeVariables
            , ForeignFunctionInterface
index edfb1bc..4831ce6 100644 (file)
            , FlexibleInstances
            , MagicHash
            , KindSignatures
-           , PolyKinds #-}
-#ifdef __GLASGOW_HASKELL__
-{-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
-#endif
+           , PolyKinds
+           , DeriveDataTypeable
+           , StandaloneDeriving #-}
 
 module Data.Typeable.Internal (
     Proxy (..),
@@ -291,19 +290,15 @@ INSTANCE_TYPEABLE1(Ratio,ratioTc,"Ratio")
 INSTANCE_TYPEABLE2((->),funTc,"->")
 INSTANCE_TYPEABLE1(IO,ioTc,"IO")
 
-#ifdef __GLASGOW_HASKELL__
 -- Types defined in GHC.MVar
 {- INSTANCE_TYPEABLE1(MVar,mvarTc,"MVar" ) -}
-#endif
 
 INSTANCE_TYPEABLE2(Array,arrayTc,"Array")
 {- INSTANCE_TYPEABLE2(IOArray,iOArrayTc,"IOArray") -}
 
-#ifdef __GLASGOW_HASKELL__
 INSTANCE_TYPEABLE2(ST,stTc,"ST")
 INSTANCE_TYPEABLE2(STRef,stRefTc,"STRef")
 INSTANCE_TYPEABLE3(STArray,sTArrayTc,"STArray")
-#endif
 
 INSTANCE_TYPEABLE2((,),pairTc,"(,)")
 INSTANCE_TYPEABLE3((,,),tup3Tc,"(,,)")
@@ -314,9 +309,7 @@ INSTANCE_TYPEABLE7((,,,,,,),tup7Tc,"(,,,,,,)")
 
 INSTANCE_TYPEABLE1(Ptr,ptrTc,"Ptr")
 INSTANCE_TYPEABLE1(FunPtr,funPtrTc,"FunPtr")
-#ifndef __GLASGOW_HASKELL__
-INSTANCE_TYPEABLE1(ForeignPtr,foreignPtrTc,"ForeignPtr")
-#endif
+
 {-
 INSTANCE_TYPEABLE1(StablePtr,stablePtrTc,"StablePtr")
 INSTANCE_TYPEABLE1(IORef,iORefTc,"IORef") 
@@ -336,9 +329,6 @@ INSTANCE_TYPEABLE0(Int,intTc,"Int")
 INSTANCE_TYPEABLE0(Word,wordTc,"Word" )
 INSTANCE_TYPEABLE0(Integer,integerTc,"Integer")
 INSTANCE_TYPEABLE0(Ordering,orderingTc,"Ordering")
-#ifndef __GLASGOW_HASKELL__
-INSTANCE_TYPEABLE0(Handle,handleTc,"Handle")
-#endif
 
 {-
 INSTANCE_TYPEABLE0(Int8,int8Tc,"Int8")
@@ -355,8 +345,6 @@ INSTANCE_TYPEABLE0(Word64,word64Tc,"Word64")
 INSTANCE_TYPEABLE0(TyCon,tyconTc,"TyCon")
 INSTANCE_TYPEABLE0(TypeRep,typeRepTc,"TypeRep")
 
-#ifdef __GLASGOW_HASKELL__
 deriving instance Typeable RealWorld
 deriving instance Typeable Proxy
 deriving instance Typeable (:=:)
-#endif
index ffd45f9..2d30cc1 100644 (file)
@@ -1,9 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP #-}
-
-#ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE MagicHash, DeriveDataTypeable #-}
-#endif
 
 -----------------------------------------------------------------------------
 -- |
@@ -30,20 +26,14 @@ import Prelude
 
 import System.IO.Unsafe (unsafePerformIO)
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.Num
 import Data.Typeable
 import Data.IORef
-#endif
 
 -- | An abstract unique object.  Objects of type 'Unique' may be
 -- compared for equality and ordering and hashed into 'Int'.
-newtype Unique = Unique Integer deriving (Eq,Ord
-#ifdef __GLASGOW_HASKELL__
-   ,Typeable
-#endif
-   )
+newtype Unique = Unique Integer deriving (Eq,Ord,Typeable)
 
 uniqSource :: IORef Integer
 uniqSource = unsafePerformIO (newIORef 0)
@@ -81,8 +71,4 @@ newUnique = do
 -- same value, although in practice this is unlikely.  The 'Int'
 -- returned makes a good hash key.
 hashUnique :: Unique -> Int
-#if defined(__GLASGOW_HASKELL__)
 hashUnique (Unique i) = I# (hashInteger i)
-#else
-hashUnique (Unique u) = fromInteger (u `mod` (toInteger (maxBound :: Int) + 1))
-#endif
index 742e051..23d2176 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, DeriveDataTypeable #-}
+{-# LANGUAGE DeriveDataTypeable #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -37,12 +37,7 @@ import Prelude -- necessary to get dependencies right
 
 import Text.ParserCombinators.ReadP
 
-#if !__GLASGOW_HASKELL__
-import Data.Typeable    ( Typeable, TyCon, mkTyCon, mkTyConApp )
-#else
 import Data.Typeable    ( Typeable )
-#endif
-
 import Data.List        ( intersperse, sort )
 import Control.Monad    ( liftM )
 import Data.Char        ( isDigit, isAlphaNum )
@@ -90,19 +85,7 @@ data Version =
                 -- The interpretation of the list of tags is entirely dependent
                 -- on the entity that this version applies to.
         }
-  deriving (Read,Show
-#if __GLASGOW_HASKELL__
-        ,Typeable
-#endif
-        )
-
-#if !__GLASGOW_HASKELL__
-versionTc :: TyCon
-versionTc = mkTyCon "Version"
-
-instance Typeable Version where
-  typeOf _ = mkTyConApp versionTc []
-#endif
+  deriving (Read,Show,Typeable)
 
 instance Eq Version where
   v1 == v2  =  versionBranch v1 == versionBranch v2 
@@ -126,9 +109,7 @@ showVersion (Version branch tags)
 
 -- | A parser for versions in the format produced by 'showVersion'.
 --
-#ifdef __GLASGOW_HASKELL__
 parseVersion :: ReadP Version
-#endif
 parseVersion = do branch <- sepBy1 (liftM read $ munch1 isDigit) (char '.')
                   tags   <- many (char '-' >> munch1 isAlphaNum)
                   return Version{versionBranch=branch, versionTags=tags}
index 8f58783..8af39b6 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Safe #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -30,9 +30,7 @@ module Data.Word
         -- $notes
         ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Word
-#endif
 
 {- $notes
 
index d4df4d9..7f78a85 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Unsafe #-}
-{-# LANGUAGE CPP, ForeignFunctionInterface, MagicHash, UnboxedTuples #-}
+{-# LANGUAGE ForeignFunctionInterface, MagicHash, UnboxedTuples #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -46,16 +46,12 @@ import Prelude
 import System.IO.Unsafe
 import Control.Monad
 
-#ifdef __GLASGOW_HASKELL__
 import Foreign.C.String
 import GHC.Base
 import qualified GHC.Foreign
 import GHC.IO.Encoding
 import GHC.Ptr
 import GHC.Stack
-#else
-import System.IO (hPutStrLn,stderr)
-#endif
 
 -- $tracing
 --
@@ -73,9 +69,6 @@ import System.IO (hPutStrLn,stderr)
 --
 traceIO :: String -> IO ()
 traceIO msg = do
-#ifndef __GLASGOW_HASKELL__
-    hPutStrLn stderr msg
-#else
     withCString "%s\n" $ \cfmt ->
      withCString msg  $ \cmsg ->
       debugBelch cfmt cmsg
@@ -84,8 +77,6 @@ traceIO msg = do
 -- using the FFI.
 foreign import ccall unsafe "HsBase.h debugBelch2"
    debugBelch :: CString -> CString -> IO ()
-#endif
-
 
 -- | Deprecated. Use 'traceIO'.
 putTraceMsg :: String -> IO ()
@@ -219,14 +210,9 @@ traceEvent msg expr = unsafeDupablePerformIO $ do
 -- other IO actions.
 --
 traceEventIO :: String -> IO ()
-#ifdef __GLASGOW_HASKELL__
 traceEventIO msg =
   GHC.Foreign.withCString utf8 msg $ \(Ptr p) -> IO $ \s ->
     case traceEvent# p s of s' -> (# s', () #)
-#else
-traceEventIO msg = (return $! length msg) >> return ()
-#endif
-
 
 -- $markers
 --
@@ -272,11 +258,6 @@ traceMarker msg expr = unsafeDupablePerformIO $ do
 -- other IO actions.
 --
 traceMarkerIO :: String -> IO ()
-#ifdef __GLASGOW_HASKELL__
 traceMarkerIO msg =
   GHC.Foreign.withCString utf8 msg $ \(Ptr p) -> IO $ \s ->
     case traceMarker# p s of s' -> (# s', () #)
-#else
-traceMarkerIO msg = (return $! length msg) >> return ()
-#endif
-
index 0d10201..ad15edb 100644 (file)
@@ -96,18 +96,11 @@ import Foreign.C.String
 import Control.Monad            ( void )
 import Data.Maybe
 
-#if __GLASGOW_HASKELL__
 import GHC.IO
 import GHC.IO.Exception
 import GHC.IO.Handle.Types
 import GHC.Num
 import GHC.Base
-#else
-import System.IO                ( Handle )
-import System.IO.Error          ( IOError, ioError )
-import System.IO.Unsafe         ( unsafePerformIO )
-import Foreign.Storable         ( Storable(poke,peek) )
-#endif
 
 -- "errno" type
 -- ------------
@@ -472,7 +465,6 @@ errnoToIOError  :: String       -- ^ the location where the error occurred
                 -> IOError
 errnoToIOError loc errno maybeHdl maybeName = unsafePerformIO $ do
     str <- strerror errno >>= peekCString
-#if __GLASGOW_HASKELL__
     return (IOError maybeHdl errType loc str (Just errno') maybeName)
     where
     Errno errno' = errno
@@ -577,9 +569,6 @@ errnoToIOError loc errno maybeHdl maybeName = unsafePerformIO $ do
         | errno == eWOULDBLOCK     = OtherError
         | errno == eXDEV           = UnsupportedOperation
         | otherwise                = OtherError
-#else
-    return (userError (loc ++ ": " ++ str ++ maybe "" (": "++) maybeName))
-#endif
 
 foreign import ccall unsafe "string.h" strerror :: Errno -> IO (Ptr CChar)
 
index 8be917a..cdbd241 100644 (file)
@@ -31,14 +31,9 @@ module Foreign.C.String (   -- representation of strings in C
 
   -- ** Using a locale-dependent encoding
 
-#ifndef __GLASGOW_HASKELL__
-  -- | Currently these functions are identical to their @CAString@ counterparts;
-  -- eventually they will use an encoding determined by the current locale.
-#else
   -- | These functions are different from their @CAString@ counterparts
   -- in that they will use an encoding determined by the current locale,
   -- rather than always assuming ASCII.
-#endif
 
   -- conversion of C strings into Haskell strings
   --
@@ -107,7 +102,6 @@ import Foreign.Storable
 
 import Data.Word
 
-#ifdef __GLASGOW_HASKELL__
 import Control.Monad
 
 import GHC.Char
@@ -118,10 +112,6 @@ import GHC.Base
 
 import {-# SOURCE #-} GHC.IO.Encoding
 import qualified GHC.Foreign as GHC
-#else
-import Data.Char ( chr, ord )
-#define unsafeChr chr
-#endif
 
 -----------------------------------------------------------------------------
 -- Strings
@@ -145,20 +135,12 @@ type CStringLen = (Ptr CChar, Int)
 -- | Marshal a NUL terminated C string into a Haskell string.
 --
 peekCString    :: CString -> IO String
-#ifndef __GLASGOW_HASKELL__
-peekCString = peekCAString
-#else
 peekCString s = getForeignEncoding >>= flip GHC.peekCString s
-#endif
 
 -- | Marshal a C string with explicit length into a Haskell string.
 --
 peekCStringLen           :: CStringLen -> IO String
-#ifndef __GLASGOW_HASKELL__
-peekCStringLen = peekCAStringLen
-#else
 peekCStringLen s = getForeignEncoding >>= flip GHC.peekCStringLen s
-#endif
 
 -- | Marshal a Haskell string into a NUL terminated C string.
 --
@@ -169,11 +151,7 @@ peekCStringLen s = getForeignEncoding >>= flip GHC.peekCStringLen s
 --   'Foreign.Marshal.Alloc.finalizerFree'.
 --
 newCString :: String -> IO CString
-#ifndef __GLASGOW_HASKELL__
-newCString = newCAString
-#else
 newCString s = getForeignEncoding >>= flip GHC.newCString s
-#endif
 
 -- | Marshal a Haskell string into a C string (ie, character array) with
 -- explicit length information.
@@ -183,11 +161,7 @@ newCString s = getForeignEncoding >>= flip GHC.newCString s
 --   'Foreign.Marshal.Alloc.finalizerFree'.
 --
 newCStringLen     :: String -> IO CStringLen
-#ifndef __GLASGOW_HASKELL__
-newCStringLen = newCAStringLen
-#else
 newCStringLen s = getForeignEncoding >>= flip GHC.newCStringLen s
-#endif
 
 -- | Marshal a Haskell string into a NUL terminated C string using temporary
 -- storage.
@@ -199,11 +173,7 @@ newCStringLen s = getForeignEncoding >>= flip GHC.newCStringLen s
 --   storage must /not/ be used after this.
 --
 withCString :: String -> (CString -> IO a) -> IO a
-#ifndef __GLASGOW_HASKELL__
-withCString = withCAString
-#else
 withCString s f = getForeignEncoding >>= \enc -> GHC.withCString enc s f
-#endif
 
 -- | Marshal a Haskell string into a C string (ie, character array)
 -- in temporary storage, with explicit length information.
@@ -213,26 +183,12 @@ withCString s f = getForeignEncoding >>= \enc -> GHC.withCString enc s f
 --   storage must /not/ be used after this.
 --
 withCStringLen         :: String -> (CStringLen -> IO a) -> IO a
-#ifndef __GLASGOW_HASKELL__
-withCStringLen = withCAStringLen
-#else
 withCStringLen s f = getForeignEncoding >>= \enc -> GHC.withCStringLen enc s f
-#endif
 
-
-#ifndef __GLASGOW_HASKELL__
--- | Determines whether a character can be accurately encoded in a 'CString'.
--- Unrepresentable characters are converted to @\'?\'@.
---
--- Currently only Latin-1 characters are representable.
-charIsRepresentable :: Char -> IO Bool
-charIsRepresentable c = return (ord c < 256)
-#else
 -- -- | Determines whether a character can be accurately encoded in a 'CString'.
 -- -- Unrepresentable characters are converted to '?' or their nearest visual equivalent.
 charIsRepresentable :: Char -> IO Bool
 charIsRepresentable c = getForeignEncoding >>= flip GHC.charIsRepresentable c
-#endif
 
 -- single byte characters
 -- ----------------------
@@ -272,11 +228,6 @@ castCharToCSChar ch = fromIntegral (ord ch)
 -- | Marshal a NUL terminated C string into a Haskell string.
 --
 peekCAString    :: CString -> IO String
-#ifndef __GLASGOW_HASKELL__
-peekCAString cp  = do
-  cs <- peekArray0 nUL cp
-  return (cCharsToChars cs)
-#else
 peekCAString cp = do
   l <- lengthArray0 nUL cp
   if l <= 0 then return "" else loop "" (l-1)
@@ -285,16 +236,10 @@ peekCAString cp = do
         xval <- peekElemOff cp i
         let val = castCCharToChar xval
         val `seq` if i <= 0 then return (val:s) else loop (val:s) (i-1)
-#endif
 
 -- | Marshal a C string with explicit length into a Haskell string.
 --
 peekCAStringLen           :: CStringLen -> IO String
-#ifndef __GLASGOW_HASKELL__
-peekCAStringLen (cp, len)  = do
-  cs <- peekArray len cp
-  return (cCharsToChars cs)
-#else
 peekCAStringLen (cp, len) 
   | len <= 0  = return "" -- being (too?) nice.
   | otherwise = loop [] (len-1)
@@ -306,7 +251,6 @@ peekCAStringLen (cp, len)
          if (val `seq` (i == 0))
           then return (val:acc)
           else loop (val:acc) (i-1)
-#endif
 
 -- | Marshal a Haskell string into a NUL terminated C string.
 --
@@ -317,9 +261,6 @@ peekCAStringLen (cp, len)
 --   'Foreign.Marshal.Alloc.finalizerFree'.
 --
 newCAString :: String -> IO CString
-#ifndef __GLASGOW_HASKELL__
-newCAString  = newArray0 nUL . charsToCChars
-#else
 newCAString str = do
   ptr <- mallocArray0 (length str)
   let
@@ -327,7 +268,6 @@ newCAString str = do
         go (c:cs) n = do pokeElemOff ptr n (castCharToCChar c); go cs (n+1)
   go str 0
   return ptr
-#endif
 
 -- | Marshal a Haskell string into a C string (ie, character array) with
 -- explicit length information.
@@ -337,9 +277,6 @@ newCAString str = do
 --   'Foreign.Marshal.Alloc.finalizerFree'.
 --
 newCAStringLen     :: String -> IO CStringLen
-#ifndef __GLASGOW_HASKELL__
-newCAStringLen str  = newArrayLen (charsToCChars str)
-#else
 newCAStringLen str = do
   ptr <- mallocArray0 len
   let
@@ -349,7 +286,6 @@ newCAStringLen str = do
   return (ptr, len)
   where
     len = length str
-#endif
 
 -- | Marshal a Haskell string into a NUL terminated C string using temporary
 -- storage.
@@ -361,9 +297,6 @@ newCAStringLen str = do
 --   storage must /not/ be used after this.
 --
 withCAString :: String -> (CString -> IO a) -> IO a
-#ifndef __GLASGOW_HASKELL__
-withCAString  = withArray0 nUL . charsToCChars
-#else
 withCAString str f =
   allocaArray0 (length str) $ \ptr ->
       let
@@ -372,7 +305,6 @@ withCAString str f =
       in do
       go str 0
       f ptr
-#endif
 
 -- | Marshal a Haskell string into a C string (ie, character array)
 -- in temporary storage, with explicit length information.
@@ -383,9 +315,6 @@ withCAString str f =
 --
 withCAStringLen         :: String -> (CStringLen -> IO a) -> IO a
 withCAStringLen str f    =
-#ifndef __GLASGOW_HASKELL__
-  withArrayLen (charsToCChars str) $ \ len ptr -> f (ptr, len)
-#else
   allocaArray len $ \ptr ->
       let
         go [] n     = n `seq` return () -- make it strict in n
@@ -395,7 +324,6 @@ withCAStringLen str f    =
       f (ptr,len)
   where
     len = length str
-#endif
 
 -- auxiliary definitions
 -- ----------------------
@@ -411,18 +339,6 @@ newArrayLen xs      = do
   a <- newArray xs
   return (a, length xs)
 
-#ifndef __GLASGOW_HASKELL__
--- cast [CChar] to [Char]
---
-cCharsToChars :: [CChar] -> [Char]
-cCharsToChars xs  = map castCCharToChar xs
-
--- cast [Char] to [CChar]
---
-charsToCChars :: [Char] -> [CChar]
-charsToCChars xs  = map castCharToCChar xs
-#endif
-
 -----------------------------------------------------------------------------
 -- Wide strings
 
index bde6be5..9951515 100644 (file)
@@ -5,9 +5,7 @@
            , GeneralizedNewtypeDeriving
   #-}
 {-# OPTIONS_GHC -fno-warn-unused-binds #-}
-#ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
-#endif
 -- XXX -fno-warn-unused-binds stops us warning about unused constructors,
 -- but really we should just remove them if we don't want them
 
@@ -66,10 +64,9 @@ module Foreign.C.Types
           -- 'Prelude.Real', 'Prelude.Fractional', 'Prelude.Floating',
           -- 'Prelude.RealFrac' and 'Prelude.RealFloat'.
         , CFloat(..),   CDouble(..)
--- GHC doesn't support CLDouble yet
-#ifndef __GLASGOW_HASKELL__
-        , CLDouble(..)
-#endif
+        -- XXX GHC doesn't support CLDouble yet
+        -- , CLDouble(..)
+
           -- ** Other types
 
           -- Instances of: Eq and Storable
@@ -82,7 +79,6 @@ import Data.Int         ( Int8,  Int16,  Int32,  Int64  )
 import Data.Word        ( Word8, Word16, Word32, Word64 )
 import Data.Typeable
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.Float
 import GHC.Enum
@@ -90,9 +86,6 @@ import GHC.Real
 import GHC.Show
 import GHC.Read
 import GHC.Num
-#else
-import Control.Monad    ( liftM )
-#endif
 
 #include "HsBaseConfig.h"
 #include "CTypes.h"
@@ -154,12 +147,7 @@ INTEGRAL_TYPE(CULLong,tyConCULLong,"CULLong",HTYPE_UNSIGNED_LONG_LONG)
 FLOATING_TYPE(CFloat,tyConCFloat,"CFloat",HTYPE_FLOAT)
 -- | Haskell type representing the C @double@ type.
 FLOATING_TYPE(CDouble,tyConCDouble,"CDouble",HTYPE_DOUBLE)
--- GHC doesn't support CLDouble yet
-#ifndef __GLASGOW_HASKELL__
--- HACK: Currently no long double in the FFI, so we simply re-use double
--- | Haskell type representing the C @long double@ type.
-FLOATING_TYPE(CLDouble,tyConCLDouble,"CLDouble",HTYPE_DOUBLE)
-#endif
+-- XXX GHC doesn't support CLDouble yet
 
 {-# RULES
 "realToFrac/a->CFloat"    realToFrac = \x -> CFloat   (realToFrac x)
index 6a21b79..9d27166 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -29,7 +29,6 @@ module Foreign.Concurrent
         addForeignPtrFinalizer,
   ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.IO         ( IO )
 import GHC.Ptr        ( Ptr )
 import GHC.ForeignPtr ( ForeignPtr )
@@ -50,5 +49,3 @@ addForeignPtrFinalizer :: ForeignPtr a -> IO () -> IO ()
 -- is dropped, but /before/ all previously registered finalizers for the
 -- same object.
 addForeignPtrFinalizer = GHC.ForeignPtr.addForeignPtrConcFinalizer
-#endif
-
index 6219adb..0017c0e 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Unsafe #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 {-# OPTIONS_HADDOCK hide #-}
 
 -----------------------------------------------------------------------------
@@ -22,22 +22,16 @@ module Foreign.ForeignPtr (
         -- * Finalised data pointers
           ForeignPtr
         , FinalizerPtr
-#ifdef __GLASGOW_HASKELL__
         , FinalizerEnvPtr
-#endif
+
         -- ** Basic operations
         , newForeignPtr
         , newForeignPtr_
         , addForeignPtrFinalizer
-#ifdef __GLASGOW_HASKELL__
         , newForeignPtrEnv
         , addForeignPtrFinalizerEnv
-#endif
         , withForeignPtr
-
-#ifdef __GLASGOW_HASKELL__
         , finalizeForeignPtr
-#endif
 
         -- ** Low-level operations
         , touchForeignPtr
index 9499fbc..2c3f393 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Unsafe #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 {-# OPTIONS_HADDOCK hide #-}
 
 -----------------------------------------------------------------------------
@@ -23,22 +23,16 @@ module Foreign.ForeignPtr.Imp
         -- * Finalised data pointers
           ForeignPtr
         , FinalizerPtr
-#ifdef __GLASGOW_HASKELL__
         , FinalizerEnvPtr
-#endif
+
         -- ** Basic operations
         , newForeignPtr
         , newForeignPtr_
         , addForeignPtrFinalizer
-#ifdef __GLASGOW_HASKELL__
         , newForeignPtrEnv
         , addForeignPtrFinalizerEnv
-#endif
         , withForeignPtr
-
-#ifdef __GLASGOW_HASKELL__
         , finalizeForeignPtr
-#endif
 
         -- ** Low-level operations
         , unsafeForeignPtrToPtr
@@ -56,25 +50,9 @@ module Foreign.ForeignPtr.Imp
 import Foreign.Ptr
 import Foreign.Storable ( Storable(sizeOf) )
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.Num
 import GHC.ForeignPtr
-#endif
-
-#if !defined(__GLASGOW_HASKELL__)
-import Foreign.Marshal.Alloc    ( malloc, mallocBytes, finalizerFree )
-
-instance Eq (ForeignPtr a) where 
-    p == q  =  unsafeForeignPtrToPtr p == unsafeForeignPtrToPtr q
-
-instance Ord (ForeignPtr a) where 
-    compare p q  =  compare (unsafeForeignPtrToPtr p) (unsafeForeignPtrToPtr q)
-
-instance Show (ForeignPtr a) where
-    showsPrec p f = showsPrec p (unsafeForeignPtrToPtr f)
-#endif
-
 
 newForeignPtr :: FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
 -- ^Turns a plain memory reference into a foreign pointer, and
@@ -112,7 +90,6 @@ withForeignPtr fo io
        touchForeignPtr fo
        return r
 
-#ifdef __GLASGOW_HASKELL__
 -- | This variant of 'newForeignPtr' adds a finalizer that expects an
 -- environment in addition to the finalized pointer.  The environment
 -- that will be passed to the finalizer is fixed by the second argument to
@@ -123,19 +100,6 @@ newForeignPtrEnv finalizer env p
   = do fObj <- newForeignPtr_ p
        addForeignPtrFinalizerEnv finalizer env fObj
        return fObj
-#endif
-
-#ifndef __GLASGOW_HASKELL__
-mallocForeignPtr :: Storable a => IO (ForeignPtr a)
-mallocForeignPtr = do
-  r <- malloc
-  newForeignPtr finalizerFree r
-
-mallocForeignPtrBytes :: Int -> IO (ForeignPtr a)
-mallocForeignPtrBytes n = do
-  r <- mallocBytes n
-  newForeignPtr finalizerFree r
-#endif /* !__GLASGOW_HASKELL__ */
 
 -- | This function is similar to 'Foreign.Marshal.Array.mallocArray',
 -- but yields a memory area that has a finalizer attached that releases
index 4289a98..190e8b6 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -23,22 +23,16 @@ module Foreign.ForeignPtr.Safe (
         -- * Finalised data pointers
           ForeignPtr
         , FinalizerPtr
-#ifdef __GLASGOW_HASKELL__
         , FinalizerEnvPtr
-#endif
+
         -- ** Basic operations
         , newForeignPtr
         , newForeignPtr_
         , addForeignPtrFinalizer
-#ifdef __GLASGOW_HASKELL__
         , newForeignPtrEnv
         , addForeignPtrFinalizerEnv
-#endif
         , withForeignPtr
-
-#ifdef __GLASGOW_HASKELL__
         , finalizeForeignPtr
-#endif
 
         -- ** Low-level operations
         , touchForeignPtr
index 7cc9a25..5a36a7e 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Unsafe #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
index 799596e..9336549 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Unsafe #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
index d68988d..9069e8a 100644 (file)
@@ -1,6 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP
-           , NoImplicitPrelude
+{-# LANGUAGE NoImplicitPrelude
            , MagicHash
            , UnboxedTuples
            , ForeignFunctionInterface
@@ -64,20 +63,11 @@ module Foreign.Marshal.Alloc (
 import Data.Maybe
 import Foreign.C.Types          ( CSize(..) )
 import Foreign.Storable         ( Storable(sizeOf,alignment) )
-
-#ifndef __GLASGOW_HASKELL__
-import Foreign.Ptr              ( Ptr, nullPtr, FunPtr )
-#endif
-
-#ifdef __GLASGOW_HASKELL__
 import Foreign.ForeignPtr       ( FinalizerPtr )
 import GHC.IO.Exception
 import GHC.Real
 import GHC.Ptr
 import GHC.Base
-#else
-import Control.Exception.Base   ( bracket )
-#endif
 
 -- exported functions
 -- ------------------
@@ -128,7 +118,6 @@ alloca  = doAlloca undefined
 -- The memory is freed when @f@ terminates (either normally or via an
 -- exception), so the pointer passed to @f@ must /not/ be used after this.
 --
-#ifdef __GLASGOW_HASKELL__
 allocaBytes :: Int -> (Ptr a -> IO b) -> IO b
 allocaBytes (I# size) action = IO $ \ s0 ->
      case newPinnedByteArray# size s0      of { (# s1, mbarr# #) ->
@@ -150,13 +139,6 @@ allocaBytesAligned (I# size) (I# align) action = IO $ \ s0 ->
      case touch# barr# s3 of { s4 ->
      (# s4, r #)
   }}}}}
-#else
-allocaBytes      :: Int -> (Ptr a -> IO b) -> IO b
-allocaBytes size  = bracket (mallocBytes size) free
-
-allocaBytesAligned :: Int -> Int -> (Ptr a -> IO b) -> IO b
-allocaBytesAligned size align = allocaBytes size -- wrong
-#endif
 
 -- |Resize a memory area that was allocated with 'malloc' or 'mallocBytes'
 -- to the size needed to store values of type @b@.  The returned pointer
@@ -213,12 +195,8 @@ failWhenNULL :: String -> IO (Ptr a) -> IO (Ptr a)
 failWhenNULL name f = do
    addr <- f
    if addr == nullPtr
-#if __GLASGOW_HASKELL__
       then ioError (IOError Nothing ResourceExhausted name 
                                         "out of memory" Nothing Nothing)
-#else
-      then ioError (userError (name++": out of memory"))
-#endif
       else return addr
 
 -- basic C routines needed for memory allocation
index d6a0041..8d7dcfb 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude, MagicHash #-}
+{-# LANGUAGE NoImplicitPrelude, MagicHash #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -69,13 +69,9 @@ import Foreign.Storable (Storable(alignment,sizeOf,peekElemOff,pokeElemOff))
 import Foreign.Marshal.Alloc (mallocBytes, allocaBytesAligned, reallocBytes)
 import Foreign.Marshal.Utils (copyBytes, moveBytes)
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Num
 import GHC.List
 import GHC.Base
-#else
-import Control.Monad (zipWithM_)
-#endif
 
 -- allocation
 -- ----------
@@ -151,28 +147,17 @@ peekArray0 marker ptr  = do
 -- |Write the list elements consecutive into memory
 --
 pokeArray :: Storable a => Ptr a -> [a] -> IO ()
-#ifndef __GLASGOW_HASKELL__
-pokeArray ptr vals =  zipWithM_ (pokeElemOff ptr) [0..] vals
-#else
 pokeArray ptr vals0 = go vals0 0#
   where go [] _          = return ()
         go (val:vals) n# = do pokeElemOff ptr (I# n#) val; go vals (n# +# 1#)
-#endif
 
 -- |Write the list elements consecutive into memory and terminate them with the
 -- given marker element
 --
 pokeArray0 :: Storable a => a -> Ptr a -> [a] -> IO ()
-#ifndef __GLASGOW_HASKELL__
-pokeArray0 marker ptr vals  = do
-  pokeArray ptr vals
-  pokeElemOff ptr (length vals) marker
-#else
 pokeArray0 marker ptr vals0 = go vals0 0#
   where go [] n#         = pokeElemOff ptr (I# n#) marker
         go (val:vals) n# = do pokeElemOff ptr (I# n#) val; go vals (n# +# 1#)
-#endif
-
 
 -- combined allocation and marshalling
 -- -----------------------------------
index e26716c..ab90e6d 100644 (file)
@@ -30,7 +30,6 @@ module Foreign.Marshal.Error (
 
 import Foreign.Ptr
 
-#ifdef __GLASGOW_HASKELL__
 #ifdef __HADDOCK__
 import Data.Bool
 import System.IO.Error
@@ -38,7 +37,6 @@ import System.IO.Error
 import GHC.Base
 import GHC.Num
 import GHC.IO.Exception
-#endif
 
 -- exported functions
 -- ------------------
index bc35dcf..8dc57ae 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 --------------------------------------------------------------------------------
 -- |
@@ -46,7 +46,6 @@ module Foreign.Marshal.Pool (
    pooledNewArray0
 ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base              ( Int, Monad(..), (.), not )
 import GHC.Err               ( undefined )
 import GHC.Exception         ( throw )
@@ -54,10 +53,6 @@ import GHC.IO                ( IO, mask, catchAny )
 import GHC.IORef             ( IORef, newIORef, readIORef, writeIORef )
 import GHC.List              ( elem, length )
 import GHC.Num               ( Num(..) )
-#else
-import Data.IORef            ( IORef, newIORef, readIORef, writeIORef )
-import Control.Exception.Base ( bracket )
-#endif
 
 import Control.Monad         ( liftM )
 import Data.List             ( delete )
@@ -93,7 +88,6 @@ freePool (Pool pool) = readIORef pool >>= freeAll
 -- deallocated (including its contents) after the action has finished.
 
 withPool :: (Pool -> IO b) -> IO b
-#ifdef __GLASGOW_HASKELL__
 withPool act =   -- ATTENTION: cut-n-paste from Control.Exception below!
    mask (\restore -> do
       pool <- newPool
@@ -102,9 +96,6 @@ withPool act =   -- ATTENTION: cut-n-paste from Control.Exception below!
                 (\e -> do freePool pool; throw e)
       freePool pool
       return val)
-#else
-withPool = bracket newPool freePool
-#endif
 
 --------------------------------------------------------------------------------
 
index 7313217..85bad2b 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Safe #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
index ee05fd4..7e986f9 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Unsafe #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -20,11 +20,7 @@ module Foreign.Marshal.Unsafe (
         unsafeLocalState
     ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.IO
-#else
-import System.IO.Unsafe
-#endif
 
 {- |
 Sometimes an external entity is a pure function, except that it passes
index dc6471a..491bd12 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude, ForeignFunctionInterface #-}
+{-# LANGUAGE NoImplicitPrelude, ForeignFunctionInterface #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -51,11 +51,9 @@ import Foreign.Storable         ( Storable(poke) )
 import Foreign.C.Types          ( CSize(..) )
 import Foreign.Marshal.Alloc    ( malloc, alloca )
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Real                 ( fromIntegral )
 import GHC.Num
 import GHC.Base
-#endif
 
 -- combined allocation and marshalling
 -- -----------------------------------
index 9c8267e..808fff6 100644 (file)
@@ -5,9 +5,7 @@
            , MagicHash
            , GeneralizedNewtypeDeriving
   #-}
-#ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
-#endif
 
 -----------------------------------------------------------------------------
 -- |
@@ -56,7 +54,6 @@ module Foreign.Ptr (
     wordPtrToPtr
  ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Ptr
 import GHC.Base
 import GHC.Num
@@ -64,28 +61,21 @@ import GHC.Read
 import GHC.Real
 import GHC.Show
 import GHC.Enum
-#else
-import Control.Monad    ( liftM )
-import Foreign.C.Types
-#endif
 
 import Data.Bits
 import Data.Typeable
 import Foreign.Storable ( Storable(..) )
 
-#ifdef __GLASGOW_HASKELL__
 -- | Release the storage associated with the given 'FunPtr', which
 -- must have been obtained from a wrapper stub.  This should be called
 -- whenever the return value from a foreign import wrapper function is
 -- no longer required; otherwise, the storage it uses will leak.
 foreign import ccall unsafe "freeHaskellFunctionPtr"
     freeHaskellFunPtr :: FunPtr a -> IO ()
-#endif
 
 #include "HsBaseConfig.h"
 #include "CTypes.h"
 
-#ifdef __GLASGOW_HASKELL__
 -- | An unsigned integral type that can be losslessly converted to and from
 -- @Ptr@. This type is also compatible with the C99 type @uintptr_t@, and
 -- can be marshalled to and from that type safely.
@@ -113,25 +103,3 @@ ptrToIntPtr (Ptr a#) = IntPtr (I# (addr2Int# a#))
 -- | casts an @IntPtr@ to a @Ptr@
 intPtrToPtr :: IntPtr -> Ptr a
 intPtrToPtr (IntPtr (I# i#)) = Ptr (int2Addr# i#)
-
-#else /* !__GLASGOW_HASKELL__ */
-
-INTEGRAL_TYPE(WordPtr,tyConWordPtr,"WordPtr",CUIntPtr)
-INTEGRAL_TYPE(IntPtr,tyConIntPtr,"IntPtr",CIntPtr)
-
-{-# CFILES cbits/PrelIOUtils.c #-}
-
-foreign import ccall unsafe "__hscore_to_uintptr"
-    ptrToWordPtr :: Ptr a -> WordPtr
-
-foreign import ccall unsafe "__hscore_from_uintptr"
-    wordPtrToPtr :: WordPtr -> Ptr a
-
-foreign import ccall unsafe "__hscore_to_intptr"
-    ptrToIntPtr :: Ptr a -> IntPtr
-
-foreign import ccall unsafe "__hscore_from_intptr"
-    intPtrToPtr :: IntPtr -> Ptr a
-
-#endif /* !__GLASGOW_HASKELL__ */
-
index 47610d6..acd89e5 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -30,9 +30,7 @@ module Foreign.StablePtr
           -- $cinterface
         ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Stable
-#endif
 
 -- $cinterface
 --
index d8189a7..86e65f8 100644 (file)
@@ -1,8 +1,6 @@
 {-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, ScopedTypeVariables #-}
-#ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE BangPatterns #-}
-#endif
 
 -----------------------------------------------------------------------------
 -- |
@@ -39,7 +37,6 @@ import Control.Monad            ( liftM )
 #include "MachDeps.h"
 #include "HsBaseConfig.h"
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Storable
 import GHC.Stable       ( StablePtr )
 import GHC.Num
@@ -50,11 +47,6 @@ import GHC.Base
 import GHC.Fingerprint.Type
 import Data.Bits
 import GHC.Real
-#else
-import Data.Int
-import Data.Word
-import Foreign.StablePtr
-#endif
 
 {- |
 The member functions of this class facilitate writing values of
@@ -146,13 +138,9 @@ class Storable a where
    -- restrictions might apply; see 'peek'.
  
    -- circular default instances
-#ifdef __GLASGOW_HASKELL__
    peekElemOff = peekElemOff_ undefined
       where peekElemOff_ :: a -> Ptr a -> Int -> IO a
             peekElemOff_ undef ptr off = peekByteOff ptr (off * sizeOf undef)
-#else
-   peekElemOff ptr off = peekByteOff ptr (off * sizeOfPtr ptr undefined)
-#endif
    pokeElemOff ptr off val = pokeByteOff ptr (off * sizeOf val) val
 
    peekByteOff ptr off = peek (ptr `plusPtr` off)
@@ -161,11 +149,6 @@ class Storable a where
    peek ptr = peekElemOff ptr 0
    poke ptr = pokeElemOff ptr 0
 
-#ifndef __GLASGOW_HASKELL__
-sizeOfPtr :: Storable a => Ptr a -> a -> Int
-sizeOfPtr px x = sizeOf x
-#endif
-
 -- System-dependent, but rather obvious instances
 
 instance Storable Bool where
@@ -181,10 +164,8 @@ instance Storable (T) where {                   \
     peekElemOff = read;                         \
     pokeElemOff = write }
 
-#ifdef __GLASGOW_HASKELL__
 STORABLE(Char,SIZEOF_INT32,ALIGNMENT_INT32,
          readWideCharOffPtr,writeWideCharOffPtr)
-#endif
 
 STORABLE(Int,SIZEOF_HSINT,ALIGNMENT_HSINT,
          readIntOffPtr,writeIntOffPtr)
@@ -232,7 +213,6 @@ STORABLE(Int64,SIZEOF_INT64,ALIGNMENT_INT64,
          readInt64OffPtr,writeInt64OffPtr)
 
 -- XXX: here to avoid orphan instance in GHC.Fingerprint
-#ifdef __GLASGOW_HASKELL__
 instance Storable Fingerprint where
   sizeOf _ = 16
   alignment _ = 8
@@ -263,5 +243,3 @@ pokeFingerprint p0 (Fingerprint high low) = do
 
       pokeW64 (castPtr p0) 8 high
       pokeW64 (castPtr p0 `plusPtr` 8) 8 low
-#endif
-
index fcea20b..d8efd72 100644 (file)
@@ -1,5 +1,4 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP #-}
 
 module GHC.Constants where
 
index 8c10702..72553bf 100644 (file)
@@ -1,6 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP
-           , NoImplicitPrelude
+{-# LANGUAGE NoImplicitPrelude
            , RankNTypes
            , ExistentialQuantification
   #-}
index e9f1212..2ec7ab5 100644 (file)
@@ -1,6 +1,6 @@
 \begin{code}
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude, MagicHash #-}
+{-# LANGUAGE NoImplicitPrelude, MagicHash #-}
 {-# OPTIONS_HADDOCK hide #-}
 
 -----------------------------------------------------------------------------
index 742bcef..ef64d48 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
index 963cb9f..e20cdf0 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude, BangPatterns #-}
+{-# LANGUAGE NoImplicitPrelude, BangPatterns #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -22,7 +22,6 @@ module GHC.IO.Device (
         SeekMode(..)
     ) where  
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.Word
 import GHC.Arr
@@ -34,7 +33,6 @@ import Data.Maybe
 import GHC.Num
 import GHC.IO
 import {-# SOURCE #-} GHC.IO.Exception ( unsupportedOperation )
-#endif
 
 -- | A low-level I/O provider where the data is bytes in memory.
 class RawIO a where
index ca231ca..3b1d072 100644 (file)
@@ -1,6 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP
-           , NoImplicitPrelude
+{-# LANGUAGE NoImplicitPrelude
            , BangPatterns
            , NondecreasingIndentation
            , MagicHash
index 0729ff2..05ee4f9 100644 (file)
@@ -1,6 +1,6 @@
 \begin{code}
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude, StandaloneDeriving, PatternGuards,
+{-# LANGUAGE NoImplicitPrelude, StandaloneDeriving, PatternGuards,
              ScopedTypeVariables #-}
 {-# OPTIONS_HADDOCK hide #-}
 
index 3b444e1..600c82f 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude, MagicHash #-}
+{-# LANGUAGE NoImplicitPrelude, MagicHash #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -57,7 +57,6 @@ module Numeric (
 
         ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.Read
 import GHC.Real
@@ -67,11 +66,7 @@ import GHC.Show
 import Data.Maybe
 import Text.ParserCombinators.ReadP( ReadP, readP_to_S, pfail )
 import qualified Text.Read.Lex as L
-#else
-import Data.Char
-#endif
 
-#ifdef __GLASGOW_HASKELL__
 -- -----------------------------------------------------------------------------
 -- Reading
 
@@ -184,7 +179,6 @@ showGFloat    :: (RealFloat a) => Maybe Int -> a -> ShowS
 showEFloat d x =  showString (formatRealFloat FFExponent d x)
 showFFloat d x =  showString (formatRealFloat FFFixed d x)
 showGFloat d x =  showString (formatRealFloat FFGeneric d x)
-#endif  /* __GLASGOW_HASKELL__ */
 
 -- ---------------------------------------------------------------------------
 -- Integer printing functions
index fdfa4fb..6be7846 100644 (file)
@@ -142,7 +142,6 @@ import Data.Either
 import Data.Maybe
 import Data.Tuple
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import Text.Read
 import GHC.Enum
@@ -150,7 +149,6 @@ import GHC.Num
 import GHC.Real
 import GHC.Float
 import GHC.Show
-#endif
 
 infixr 0 $!
 
@@ -159,11 +157,7 @@ infixr 0 $!
 
 -- | Strict (call-by-value) application, defined in terms of 'seq'.
 ($!)    :: (a -> b) -> a -> b
-#ifdef __GLASGOW_HASKELL__
 f $! x  = let !vx = x in f vx  -- see #2273
-#else
-f $! x  = x `seq` f x
-#endif
 
 #ifdef __HADDOCK__
 -- | The value of @'seq' a b@ is bottom if @a@ is bottom, and otherwise
index ab8f86c..0ea6dfb 100644 (file)
@@ -28,7 +28,6 @@ import Prelude
 
 import Data.Ratio
 
-#ifdef __GLASGOW_HASKELL__
 import Foreign.Safe
 import Foreign.C
 
@@ -49,8 +48,6 @@ import Foreign.C
 #include <sys/times.h>
 #endif
 
-#endif
-
 ##ifdef mingw32_HOST_OS
 ## if defined(i386_HOST_ARCH)
 ##  define WINDOWS_CCONV stdcall
@@ -69,7 +66,6 @@ realToInteger ct = round (realToFrac ct :: Double)
   -- so we must convert to Double before we can round it
 #endif
 
-#ifdef __GLASGOW_HASKELL__
 -- -----------------------------------------------------------------------------
 -- |Computation 'getCPUTime' returns the number of picoseconds CPU time
 -- used by the current program.  The precision of this result is
@@ -152,7 +148,7 @@ foreign import WINDOWS_CCONV unsafe "GetCurrentProcess" getCurrentProcess :: IO
 foreign import WINDOWS_CCONV unsafe "GetProcessTimes" getProcessTimes :: Ptr HANDLE -> Ptr FILETIME -> Ptr FILETIME -> Ptr FILETIME -> Ptr FILETIME -> IO CInt
 
 #endif /* not _WIN32 */
-#endif /* __GLASGOW_HASKELL__ */
+
 
 -- |The 'cpuTimePrecision' constant is the smallest measurable difference
 -- in CPU time that the implementation can record, and is given as an
@@ -161,9 +157,7 @@ foreign import WINDOWS_CCONV unsafe "GetProcessTimes" getProcessTimes :: Ptr HAN
 cpuTimePrecision :: Integer
 cpuTimePrecision = round ((1000000000000::Integer) % fromIntegral (clockTicks))
 
-#ifdef __GLASGOW_HASKELL__
 foreign import ccall unsafe clk_tck :: CLong
 
 clockTicks :: Int
 clockTicks = fromIntegral clk_tck
-#endif /* __GLASGOW_HASKELL__ */
index 25aa6f4..8397fc3 100644 (file)
@@ -26,14 +26,11 @@ module System.Environment
       unsetEnv,
       withArgs,
       withProgName,
-#ifdef __GLASGOW_HASKELL__
       getEnvironment,
-#endif
   ) where
 
 import Prelude
 
-#ifdef __GLASGOW_HASKELL__
 import Foreign.Safe
 import Foreign.C
 import System.IO.Error (mkIOError)
@@ -50,7 +47,6 @@ import GHC.Windows
 #else
 import System.Posix.Internals (withFilePath)
 #endif
-#endif
 
 import System.Environment.ExecutablePath
 
@@ -64,8 +60,6 @@ import System.Environment.ExecutablePath
 # endif
 #endif
 
-#ifdef __GLASGOW_HASKELL__
-
 #include "HsBaseConfig.h"
 
 -- ---------------------------------------------------------------------------
@@ -449,4 +443,3 @@ divvy str =
   case break (=='=') str of
     (xs,[])        -> (xs,[]) -- don't barf (like Posix.getEnvironment)
     (name,_:value) -> (name,value)
-#endif  /* __GLASGOW_HASKELL__ */
index dbe2ce0..a3059fc 100644 (file)
@@ -1,5 +1,4 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -25,10 +24,8 @@ module System.Exit
 
 import Prelude
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.IO
 import GHC.IO.Exception
-#endif
 
 -- ---------------------------------------------------------------------------
 -- exitWith
@@ -63,9 +60,7 @@ exitWith :: ExitCode -> IO a
 exitWith ExitSuccess = throwIO ExitSuccess
 exitWith code@(ExitFailure n)
   | n /= 0 = throwIO code
-#ifdef __GLASGOW_HASKELL__
   | otherwise = ioError (IOError Nothing InvalidArgument "exitWith" "ExitFailure 0" Nothing Nothing)
-#endif
 
 -- | The computation 'exitFailure' is equivalent to
 -- 'exitWith' @(@'ExitFailure' /exitfail/@)@,
index d6ed1f5..93245d3 100644 (file)
@@ -73,9 +73,7 @@ module System.IO (
     -- ** Determining and changing the size of a file
 
     hFileSize,
-#ifdef __GLASGOW_HASKELL__
     hSetFileSize,
-#endif
 
     -- ** Detecting the end of input
 
@@ -114,9 +112,7 @@ module System.IO (
 
     -- ** Showing handle state (not portable: GHC only)
 
-#ifdef __GLASGOW_HASKELL__
     hShow,
-#endif
 
     -- * Text input and output
 
@@ -237,7 +233,6 @@ import Foreign.C.Types
 import System.Posix.Internals
 import System.Posix.Types
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.IO hiding ( bracket, onException )
 import GHC.IO.IOMode
@@ -251,12 +246,10 @@ import GHC.Num
 import Text.Read
 import GHC.Show
 import GHC.MVar
-#endif
 
 -- -----------------------------------------------------------------------------
 -- Standard IO
 
-#ifdef __GLASGOW_HASKELL__
 -- | Write a character to the standard output device
 -- (same as 'hPutChar' 'stdout').
 
@@ -364,7 +357,6 @@ readIO s        =  case (do { (x,t) <- reads s ;
 -- 'GHC.IO.Encoding.setLocaleEncoding' this value will not reflect that change.
 localeEncoding :: TextEncoding
 localeEncoding = initLocaleEncoding
-#endif  /* __GLASGOW_HASKELL__ */
 
 -- | Computation 'hReady' @hdl@ indicates whether at least one item is
 -- available for input from handle @hdl@.
@@ -408,7 +400,6 @@ withBinaryFile name mode = bracket (openBinaryFile name mode) hClose
 -- ---------------------------------------------------------------------------
 -- fixIO
 
-#if defined(__GLASGOW_HASKELL__)
 fixIO :: (a -> IO a) -> IO a
 fixIO k = do
     m <- newEmptyMVar
@@ -431,7 +422,6 @@ fixIO k = do
 --
 -- See also System.IO.Unsafe.unsafeFixIO.
 --
-#endif
 
 -- | The function creates a temporary file in ReadWrite mode.
 -- The created file isn\'t deleted automatically, so you need to delete it manually.
@@ -496,7 +486,6 @@ openTempFile' loc tmp_dir template binary mode = do
          -- beginning with '.' as the second component.
          _                      -> error "bug in System.IO.openTempFile"
 
-#if defined(__GLASGOW_HASKELL__)
     findTempName x = do
       r <- openNewFile filepath binary mode
       case r of
@@ -511,10 +500,6 @@ openTempFile' loc tmp_dir template binary mode = do
           h <- mkHandleFromFD fD fd_type filepath ReadWriteMode False{-set non-block-} (Just enc)
 
           return (filepath, h)
-#else
-         h <- fdToHandle fd `onException` c_close fd
-         return (filepath, h)
-#endif
 
       where
         filename        = prefix ++ show x ++ suffix
@@ -527,7 +512,6 @@ openTempFile' loc tmp_dir template binary mode = do
                   | last a == pathSeparator = a ++ b
                   | otherwise = a ++ [pathSeparator] ++ b
 
-#if defined(__GLASGOW_HASKELL__)
 data OpenNewFileResult
   = NewFileCreated CInt
   | FileExists
@@ -549,7 +533,7 @@ openNewFile filepath binary mode = do
       errno <- getErrno
       case errno of
         _ | errno == eEXIST -> return FileExists
-# ifdef mingw32_HOST_OS
+#ifdef mingw32_HOST_OS
         -- If c_open throws EACCES on windows, it could mean that filepath is a
         -- directory. In this case, we want to return FileExists so that the
         -- enclosing openTempFile can try again instead of failing outright.
@@ -564,13 +548,12 @@ openNewFile filepath binary mode = do
           return $ if exists
             then FileExists
             else OpenNewError errno
-# endif
+#endif
         _ -> return (OpenNewError errno)
     else return (NewFileCreated fd)
 
-# ifdef mingw32_HOST_OS
+#ifdef mingw32_HOST_OS
 foreign import ccall "file_exists" c_fileExists :: CString -> IO Bool
-# endif
 #endif
 
 -- XXX Should use filepath library
index d762056..3486769 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -86,13 +86,11 @@ import Control.Exception.Base
 import Data.Either
 import Data.Maybe
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.IO
 import GHC.IO.Exception
 import GHC.IO.Handle.Types
 import Text.Show
-#endif
 
 -- | The construct 'tryIOError' @comp@ exposes IO errors which occur within a
 -- computation, and which are not fully handled.
@@ -116,9 +114,7 @@ mkIOError t location maybe_hdl maybe_filename =
                IOError{ ioe_type = t, 
                         ioe_location = location,
                         ioe_description = "",
-#if defined(__GLASGOW_HASKELL__)
                         ioe_errno = Nothing,
-#endif
                         ioe_handle = maybe_hdl, 
                         ioe_filename = maybe_filename
                         }
index 18a2d42..eb6eef6 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Unsafe #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -23,13 +23,11 @@ module System.IO.Unsafe (
    unsafeFixIO,
   ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.IO
 import GHC.IORef
 import GHC.Exception
 import Control.Exception
-#endif
 
 -- | A slightly faster version of `System.IO.fixIO` that may not be
 -- safe to use with multiple threads.  The unsafety arises when used
index d387240..1d251bc 100644 (file)
@@ -33,26 +33,20 @@ compilerVersion :: Version
 compilerVersion = Version {versionBranch=[major, minor], versionTags=[]}
   where (major, minor) = compilerVersionRaw `divMod` 100
 
+#include "ghcplatform.h"
+
 -- | The operating system on which the program is running.
 os :: String
+os = HOST_OS
 
 -- | The machine architecture on which the program is running.
 arch :: String
+arch = HOST_ARCH
 
 -- | The Haskell implementation with which the program was compiled
 -- or is being interpreted.
 compilerName :: String
+compilerName = "ghc"
 
 compilerVersionRaw :: Int
-
-#if defined(__GLASGOW_HASKELL__)
-#include "ghcplatform.h"
-os = HOST_OS
-arch = HOST_ARCH
-compilerName = "ghc"
 compilerVersionRaw = __GLASGOW_HASKELL__
-
-#else
-#error Unknown compiler name
-#endif
-
index 8bcf37a..05d9d00 100644 (file)
@@ -1,8 +1,5 @@
 {-# LANGUAGE Safe #-}
-{-# LANGUAGE CPP #-}
-#ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE ForeignFunctionInterface #-}
-#endif
 
 -----------------------------------------------------------------------------
 -- |
@@ -24,8 +21,5 @@ module System.Mem (
  
 import Prelude
 
-#ifdef __GLASGOW_HASKELL__
 -- | Triggers an immediate garbage collection
 foreign import ccall {-safe-} "performMajorGC" performGC :: IO ()
-#endif
-
index 374f01c..2cd09fe 100644 (file)
@@ -1,12 +1,10 @@
 {-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
-#ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
 {-# LANGUAGE MagicHash #-}
 #if !defined(__PARALLEL_HASKELL__)
 {-# LANGUAGE UnboxedTuples #-}
 #endif
-#endif
 
 -----------------------------------------------------------------------------
 -- |
@@ -44,7 +42,6 @@ import Prelude
 
 import Data.Typeable
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.IO           ( IO(..) )
 import GHC.Base                ( Int(..), StableName#, makeStableName#
                        , eqStableName#, stableNameToInt# )
@@ -127,8 +124,6 @@ eqStableName (StableName sn1) (StableName sn2) =
   -- Requested by Emil Axelsson on glasgow-haskell-users, who wants to
   -- use it for implementing observable sharing.
 
-#endif /* __GLASGOW_HASKELL__ */
-
 #include "Typeable.h"
 INSTANCE_TYPEABLE1(StableName,stableNameTc,"StableName")
 
index f350086..fc69019 100644 (file)
@@ -1,5 +1,4 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -70,9 +69,7 @@ module System.Mem.Weak (
        -- $precise
    ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Weak
-#endif
 
 -- | A specialised version of 'mkWeak', where the key and the value are
 -- the same object:
index 156ab28..833366e 100644 (file)
@@ -41,7 +41,6 @@ import Data.Maybe
 import System.IO.Error
 #endif
 
-#if __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.Num
 import GHC.Real
@@ -53,7 +52,6 @@ import GHC.IO.Device
 import {-# SOURCE #-} GHC.IO.Encoding (getFileSystemEncoding)
 import qualified GHC.Foreign as GHC
 #endif
-#endif
 
 -- ---------------------------------------------------------------------------
 -- Debugging the base package
@@ -137,9 +135,7 @@ statGetType p_stat = do
 ioe_unknownfiletype :: IOException
 ioe_unknownfiletype = IOError Nothing UnsupportedOperation "fdType"
                         "unknown file type"
-#if __GLASGOW_HASKELL__
                         Nothing
-#endif
                         Nothing
 
 fdGetMode :: FD -> IO IOMode
@@ -182,17 +178,10 @@ newFilePath :: FilePath -> IO CString
 peekFilePath :: CString -> IO FilePath
 peekFilePathLen :: CStringLen -> IO FilePath
 
-#if __GLASGOW_HASKELL__
 withFilePath fp f = getFileSystemEncoding >>= \enc -> GHC.withCString enc fp f
 newFilePath fp = getFileSystemEncoding >>= \enc -> GHC.newCString enc fp
 peekFilePath fp = getFileSystemEncoding >>= \enc -> GHC.peekCString enc fp
 peekFilePathLen fp = getFileSystemEncoding >>= \enc -> GHC.peekCStringLen enc fp
-#else
-withFilePath = withCString
-newFilePath = newCString
-peekFilePath = peekCString
-peekFilePathLen = peekCStringLen
-#endif
 
 #endif
 
@@ -240,7 +229,6 @@ tcSetAttr fd fun = do
         throwErrnoIfMinus1Retry_ "tcSetAttr"
            (c_tcgetattr fd p_tios)
 
-#ifdef __GLASGOW_HASKELL__
         -- Save a copy of termios, if this is a standard file descriptor.
         -- These terminal settings are restored in hs_exit().
         when (fd <= 2) $ do
@@ -249,7 +237,6 @@ tcSetAttr fd fun = do
              saved_tios <- mallocBytes sizeof_termios
              copyBytes saved_tios p_tios sizeof_termios
              set_saved_termios fd saved_tios
-#endif
 
         -- tcsetattr() when invoked by a background process causes the process
         -- to be sent SIGTTOU regardless of whether the process has TOSTOP set
@@ -271,13 +258,11 @@ tcSetAttr fd fun = do
                  c_sigprocmask const_sig_setmask p_old_sigset nullPtr
              return r
 
-#ifdef __GLASGOW_HASKELL__
 foreign import ccall unsafe "HsBase.h __hscore_get_saved_termios"
    get_saved_termios :: CInt -> IO (Ptr CTermios)
 
 foreign import ccall unsafe "HsBase.h __hscore_set_saved_termios"
    set_saved_termios :: CInt -> (Ptr CTermios) -> IO ()
-#endif
 
 #else
 
index 82760c5..dd5b987 100644 (file)
@@ -4,9 +4,7 @@
            , MagicHash
            , GeneralizedNewtypeDeriving
   #-}
-#ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
-#endif
 
 -----------------------------------------------------------------------------
 -- |
@@ -97,7 +95,6 @@ import Foreign.C
 import Data.Typeable
 -- import Data.Bits
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.Enum
 import GHC.Num
@@ -105,9 +102,6 @@ import GHC.Real
 -- import GHC.Prim
 import GHC.Read
 import GHC.Show
-#else
-import Control.Monad
-#endif
 
 #include "CTypes.h"
 
index 559ca42..a7b124a 100644 (file)
@@ -1,8 +1,6 @@
 {-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
-#ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
-#endif
 
 -------------------------------------------------------------------------------
 -- |
 --
 -------------------------------------------------------------------------------
 
-#ifdef __GLASGOW_HASKELL__
 #include "Typeable.h"
-#endif
 
 module System.Timeout ( timeout ) where
 
-#ifdef __GLASGOW_HASKELL__
 #ifndef mingw32_HOST_OS
 import Control.Monad
 import GHC.Event           (getSystemTimerManager,
@@ -54,8 +49,6 @@ instance Exception Timeout where
   toException = asyncExceptionToException
   fromException = asyncExceptionFromException
 
-#endif /* !__GLASGOW_HASKELL__ */
-
 -- |Wrap an 'IO' computation to time out and return @Nothing@ in case no result
 -- is available within @n@ microseconds (@1\/10^6@ seconds). In case a result
 -- is available before the timeout expires, @Just a@ is returned. A negative
@@ -86,7 +79,6 @@ instance Exception Timeout where
 -- I\/O or file I\/O using this combinator.
 
 timeout :: Int -> IO a -> IO (Maybe a)
-#ifdef __GLASGOW_HASKELL__
 timeout n f
     | n <  0    = fmap Just f
     | n == 0    = return Nothing
@@ -131,7 +123,3 @@ timeout n f
                             (uninterruptibleMask_ . killThread)
                             (\_ -> fmap Just f))
         -- #7719 explains why we need uninterruptibleMask_ above.
-#else
-timeout n f = fmap Just f
-#endif /* !__GLASGOW_HASKELL__ */
-
index 7233884..a0e6e22 100644 (file)
@@ -1,9 +1,7 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 {-# LANGUAGE RankNTypes #-}
-#ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE MagicHash #-}
-#endif
 
 -----------------------------------------------------------------------------
 -- |
@@ -75,17 +73,12 @@ module Text.ParserCombinators.ReadP
 
 import Control.Monad( MonadPlus(..), sequence, liftM2 )
 
-#ifdef __GLASGOW_HASKELL__
 import {-# SOURCE #-} GHC.Unicode ( isSpace  )
 import GHC.List ( replicate, null )
 import GHC.Base
-#else
-import Data.Char( isSpace )
-#endif
 
 infixr 5 +++, <++
 
-#ifdef __GLASGOW_HASKELL__
 ------------------------------------------------------------------------
 -- ReadS
 
@@ -95,7 +88,6 @@ infixr 5 +++, <++
 -- Note that this kind of backtracking parser is very inefficient;
 -- reading a large structure may be quite slow (cf 'ReadP').
 type ReadS a = String -> [(a,String)]
-#endif
 
 -- ---------------------------------------------------------------------------
 -- The P type
@@ -209,7 +201,6 @@ R f1 +++ R f2 = R (\k -> f1 k `mplus` f2 k)
 -- ^ Local, exclusive, left-biased choice: If left parser
 --   locally produces any result at all, then right parser is
 --   not used.
-#ifdef __GLASGOW_HASKELL__
 R f0 <++ q =
   do s <- look
      probe (f0 return) s 0#
@@ -222,20 +213,6 @@ R f0 <++ q =
 
   discard 0# = return ()
   discard n  = get >> discard (n-#1#)
-#else
-R f <++ q =
-  do s <- look
-     probe (f return) s 0
- where
-  probe (Get f)        (c:s) n = probe (f c) s (n+1)
-  probe (Look f)       s     n = probe (f s) s n
-  probe p@(Result _ _) _     n = discard n >> R (p >>=)
-  probe (Final r)      _     _ = R (Final r >>=)
-  probe _              _     _ = q
-
-  discard 0 = return ()
-  discard n  = get >> discard (n-1)
-#endif
 
 gather :: ReadP a -> ReadP (String, a)
 -- ^ Transforms a parser into one that does the same, but
index ba59fac..235436c 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -62,10 +62,8 @@ import qualified Text.ParserCombinators.ReadP as ReadP
   )
 
 import Control.Monad( MonadPlus(..) )
-#ifdef __GLASGOW_HASKELL__
 import GHC.Num( Num(..) )
 import GHC.Base
-#endif
 
 -- ---------------------------------------------------------------------------
 -- The readPrec type
index 4e9c65d..1766f9b 100644 (file)
@@ -1,5 +1,4 @@
 {-# LANGUAGE Safe #-}
-{-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
 -- |
index 568c746..b2c3d6b 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -32,35 +32,26 @@ module Text.Read (
    readParen,
    lex,
 
-#ifdef __GLASGOW_HASKELL__
    -- * New parsing functions
    module Text.ParserCombinators.ReadPrec,
    L.Lexeme(..),
    lexP,
    parens,
-#endif
-#ifdef __GLASGOW_HASKELL__
    readListDefault,
    readListPrecDefault,
    readEither,
    readMaybe
-#endif
 
  ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.Read
 import Data.Either
 import Data.Maybe
 import Text.ParserCombinators.ReadP as P
-#endif
-#ifdef __GLASGOW_HASKELL__
 import Text.ParserCombinators.ReadPrec
 import qualified Text.Read.Lex as L
-#endif
 
-#ifdef __GLASGOW_HASKELL__
 ------------------------------------------------------------------------
 -- utility functions
 
@@ -94,5 +85,3 @@ readMaybe s = case readEither s of
 -- completely consumed by the input process.
 read :: Read a => String -> a
 read s = either error id (readEither s)
-#endif
-
index 78f4913..637299a 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -35,7 +35,6 @@ module Text.Read.Lex
 
 import Text.ParserCombinators.ReadP
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.Char
 import GHC.Num( Num(..), Integer )
@@ -45,11 +44,6 @@ import GHC.Real( Rational, (%), fromIntegral,
                  toInteger, (^) )
 import GHC.List
 import GHC.Enum( minBound, maxBound )
-#else
-import Prelude hiding ( lex )
-import Data.Char( chr, ord, isSpace, isAlpha, isAlphaNum )
-import Data.Ratio( Ratio, (%) )
-#endif
 import Data.Maybe
 import Control.Monad
 
index d37f715..6978a0e 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Safe #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -26,21 +26,9 @@ module Text.Show (
    showListWith,
  ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Show
-#endif
 
 -- | Show a list (using square brackets and commas), given a function
 -- for showing elements.
 showListWith :: (a -> ShowS) -> [a] -> ShowS
 showListWith = showList__
-
-#ifndef __GLASGOW_HASKELL__
-showList__ :: (a -> ShowS) ->  [a] -> ShowS
-showList__ _     []     s = "[]" ++ s
-showList__ showx (x:xs) s = '[' : showx x (showl xs)
-  where
-    showl []     = ']' : s
-    showl (y:ys) = ',' : showx y (showl ys)
-#endif
-
index 27cdd60..b34cbc6 100644 (file)
@@ -1,5 +1,4 @@
 {-# LANGUAGE Safe #-}
-{-# LANGUAGE CPP #-}
 -- This module deliberately declares orphan instances:
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
index 11557c3..1cd70a6 100644 (file)
@@ -1,5 +1,5 @@
 {-# LANGUAGE Unsafe #-}
-{-# LANGUAGE CPP, NoImplicitPrelude, MagicHash #-}
+{-# LANGUAGE NoImplicitPrelude, MagicHash #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -31,8 +31,6 @@
 
 module Unsafe.Coerce (unsafeCoerce) where
 
-
-#if defined(__GLASGOW_HASKELL__)
 import GHC.Integer () -- for build ordering
 import GHC.Prim (unsafeCoerce#)
 
@@ -62,4 +60,3 @@ unsafeCoerce x = local_id (unsafeCoerce# x)
   -- See Note [Unsafe coerce magic] in basicTypes/MkId
   -- NB: Do not eta-reduce this definition, else the type checker 
   -- give usafeCoerce the same (dangerous) type as unsafeCoerce#
-#endif
index 14ec79d..a33d1fa 100644 (file)
 // macros below are modified, otherwise the layout rule will bite you.
 -}
 
---  // A hacked version for GHC follows the Haskell 98 version...
-#ifndef __GLASGOW_HASKELL__
-
-#define ARITHMETIC_TYPE(T,C,S,B) \
-newtype T = T B deriving (Eq, Ord) ; \
-INSTANCE_NUM(T) ; \
-INSTANCE_REAL(T) ; \
-INSTANCE_READ(T,B) ; \
-INSTANCE_SHOW(T,B) ; \
-INSTANCE_ENUM(T) ; \
-INSTANCE_STORABLE(T) ; \
-INSTANCE_TYPEABLE0(T,C,S) ;
-
-#define INTEGRAL_TYPE(T,C,S,B) \
-ARITHMETIC_TYPE(T,C,S,B) ; \
-INSTANCE_BOUNDED(T) ; \
-INSTANCE_INTEGRAL(T) ; \
-INSTANCE_BITS(T)
-
-#define FLOATING_TYPE(T,C,S,B) \
-ARITHMETIC_TYPE(T,C,S,B) ; \
-INSTANCE_FRACTIONAL(T) ; \
-INSTANCE_FLOATING(T) ; \
-INSTANCE_REALFRAC(T) ; \
-INSTANCE_REALFLOAT(T)
-
-#ifndef __GLASGOW_HASKELL__
-#define fakeMap map
-#endif
-
-#define INSTANCE_READ(T,B) \
-instance Read T where { \
-   readsPrec p s = fakeMap (\(x, t) -> (T x, t)) (readsPrec p s) }
-
-#define INSTANCE_SHOW(T,B) \
-instance Show T where { \
-   showsPrec p (T x) = showsPrec p x }
-
-#define INSTANCE_NUM(T) \
-instance Num T where { \
-   (T i) + (T j) = T (i + j) ; \
-   (T i) - (T j) = T (i - j) ; \
-   (T i) * (T j) = T (i * j) ; \
-   negate  (T i) = T (negate i) ; \
-   abs     (T i) = T (abs    i) ; \
-   signum  (T i) = T (signum i) ; \
-   fromInteger x = T (fromInteger x) }
-
-#define INSTANCE_BOUNDED(T) \
-instance Bounded T where { \
-   minBound = T minBound ; \
-   maxBound = T maxBound }
-
-#define INSTANCE_ENUM(T) \
-instance Enum T where { \
-   succ           (T i)             = T (succ i) ; \
-   pred           (T i)             = T (pred i) ; \
-   toEnum               x           = T (toEnum x) ; \
-   fromEnum       (T i)             = fromEnum i ; \
-   enumFrom       (T i)             = fakeMap T (enumFrom i) ; \
-   enumFromThen   (T i) (T j)       = fakeMap T (enumFromThen i j) ; \
-   enumFromTo     (T i) (T j)       = fakeMap T (enumFromTo i j) ; \
-   enumFromThenTo (T i) (T j) (T k) = fakeMap T (enumFromThenTo i j k) }
-
-#define INSTANCE_REAL(T) \
-instance Real T where { \
-   toRational (T i) = toRational i }
-
-#define INSTANCE_INTEGRAL(T) \
-instance Integral T where { \
-   (T i) `quot`    (T j) = T (i `quot` j) ; \
-   (T i) `rem`     (T j) = T (i `rem`  j) ; \
-   (T i) `div`     (T j) = T (i `div`  j) ; \
-   (T i) `mod`     (T j) = T (i `mod`  j) ; \
-   (T i) `quotRem` (T j) = let (q,r) = i `quotRem` j in (T q, T r) ; \
-   (T i) `divMod`  (T j) = let (d,m) = i `divMod`  j in (T d, T m) ; \
-   toInteger (T i)       = toInteger i }
-
-#define INSTANCE_BITS(T) \
-instance Bits T where { \
-  (T x) .&.     (T y)   = T (x .&.   y) ; \
-  (T x) .|.     (T y)   = T (x .|.   y) ; \
-  (T x) `xor`   (T y)   = T (x `xor` y) ; \
-  complement    (T x)   = T (complement x) ; \
-  shift         (T x) n = T (shift x n) ; \
-  unsafeShiftL  (T x) n = T (unsafeShiftL x n) ; \
-  unsafeShiftR  (T x) n = T (unsafeShiftR x n) ; \
-  rotate        (T x) n = T (rotate x n) ; \
-  bit                 n = T (bit n) ; \
-  setBit        (T x) n = T (setBit x n) ; \
-  clearBit      (T x) n = T (clearBit x n) ; \
-  complementBit (T x) n = T (complementBit x n) ; \
-  testBit       (T x) n = testBit x n ; \
-  bitSize       (T x)   = bitSize x ; \
-  isSigned      (T x)   = isSigned x ; \
-  popCount      (T x)   = popCount x }
-
-#define INSTANCE_FRACTIONAL(T) \
-instance Fractional T where { \
-   (T x) / (T y)  = T (x / y) ; \
-   recip   (T x)  = T (recip x) ; \
-   fromRational r = T (fromRational r) }
-
-#define INSTANCE_FLOATING(T) \
-instance Floating T where { \
-   pi                    = pi ; \
-   exp   (T x)           = T (exp   x) ; \
-   log   (T x)           = T (log   x) ; \
-   sqrt  (T x)           = T (sqrt  x) ; \
-   (T x) **        (T y) = T (x ** y) ; \
-   (T x) `logBase` (T y) = T (x `logBase` y) ; \
-   sin   (T x)           = T (sin   x) ; \
-   cos   (T x)           = T (cos   x) ; \
-   tan   (T x)           = T (tan   x) ; \
-   asin  (T x)           = T (asin  x) ; \
-   acos  (T x)           = T (acos  x) ; \
-   atan  (T x)           = T (atan  x) ; \
-   sinh  (T x)           = T (sinh  x) ; \
-   cosh  (T x)           = T (cosh  x) ; \
-   tanh  (T x)           = T (tanh  x) ; \
-   asinh (T x)           = T (asinh x) ; \
-   acosh (T x)           = T (acosh x) ; \
-   atanh (T x)           = T (atanh x) }
-
-#define INSTANCE_REALFRAC(T) \
-instance RealFrac T where { \
-   properFraction (T x) = let (m,y) = properFraction x in (m, T y) ; \
-   truncate (T x) = truncate x ; \
-   round    (T x) = round x ; \
-   ceiling  (T x) = ceiling x ; \
-   floor    (T x) = floor x }
-
-#define INSTANCE_REALFLOAT(T) \
-instance RealFloat T where { \
-   floatRadix     (T x) = floatRadix x ; \
-   floatDigits    (T x) = floatDigits x ; \
-   floatRange     (T x) = floatRange x ; \
-   decodeFloat    (T x) = decodeFloat x ; \
-   encodeFloat m n      = T (encodeFloat m n) ; \
-   exponent       (T x) = exponent x ; \
-   significand    (T x) = T (significand  x) ; \
-   scaleFloat n   (T x) = T (scaleFloat n x) ; \
-   isNaN          (T x) = isNaN x ; \
-   isInfinite     (T x) = isInfinite x ; \
-   isDenormalized (T x) = isDenormalized x ; \
-   isNegativeZero (T x) = isNegativeZero x ; \
-   isIEEE         (T x) = isIEEE x ; \
-   (T x) `atan2`  (T y) = T (x `atan2` y) }
-
-#define INSTANCE_STORABLE(T) \
-instance Storable T where { \
-   sizeOf    (T x)       = sizeOf x ; \
-   alignment (T x)       = alignment x ; \
-   peekElemOff a i       = liftM T (peekElemOff (castPtr a) i) ; \
-   pokeElemOff a i (T x) = pokeElemOff (castPtr a) i x }
-
-#else /* __GLASGOW_HASKELL__ */
-
 --  // GHC can derive any class for a newtype, so we make use of that here...
 
 #define ARITHMETIC_CLASSES  Eq,Ord,Num,Enum,Storable,Real
@@ -215,6 +57,4 @@ instance Show T where { \
    show                 = unsafeCoerce# (show :: B -> String); \
    showList             = unsafeCoerce# (showList :: [B] -> ShowS); }
 
-#endif /* __GLASGOW_HASKELL__ */
-
 #endif
index b70a729..46d0f0c 100644 (file)
@@ -305,10 +305,6 @@ __hscore_setmode( int fd, HsBool toBin )
 #endif
 }
 
-#if __GLASGOW_HASKELL__
-
-#endif /* __GLASGOW_HASKELL__ */
-
 #if defined(__MINGW32__)
 // We want the versions of stat/fstat/lseek that use 64-bit offsets,
 // and you have to ask for those explicitly.  Unfortunately there
index 38fe90f..311edff 100644 (file)
@@ -14,8 +14,6 @@
 #ifndef TYPEABLE_H
 #define TYPEABLE_H
 
-#ifdef __GLASGOW_HASKELL__
-
 --  // For GHC, we can use DeriveDataTypeable + StandaloneDeriving to
 --  // generate the instances.
 
 #define INSTANCE_TYPEABLE6(tycon,tcname,str) deriving instance Typeable6 tycon
 #define INSTANCE_TYPEABLE7(tycon,tcname,str) deriving instance Typeable7 tycon
 
-#else /* !__GLASGOW_HASKELL__ */
-
-#define INSTANCE_TYPEABLE0(tycon,tcname,str) \
-tcname :: TyCon; \
-tcname = mkTyCon str; \
-instance Typeable tycon where { typeOf _ = mkTyConApp tcname [] }
-
-#define INSTANCE_TYPEABLE1(tycon,tcname,str) \
-tcname = mkTyCon str; \
-instance Typeable1 tycon where { typeOf1 _ = mkTyConApp tcname [] }; \
-instance Typeable a => Typeable (tycon a) where { typeOf = typeOfDefault }
-
-#define INSTANCE_TYPEABLE2(tycon,tcname,str) \
-tcname = mkTyCon str; \
-instance Typeable2 tycon where { typeOf2 _ = mkTyConApp tcname [] }; \
-instance Typeable a => Typeable1 (tycon a) where { \
-  typeOf1 = typeOf1Default }; \
-instance (Typeable a, Typeable b) => Typeable (tycon a b) where { \
-  typeOf = typeOfDefault }
-
-#define INSTANCE_TYPEABLE3(tycon,tcname,str) \
-tcname = mkTyCon str; \
-instance Typeable3 tycon where { typeOf3 _ = mkTyConApp tcname [] }; \
-instance Typeable a => Typeable2 (tycon a) where { \
-  typeOf2 = typeOf2Default }; \
-instance (Typeable a, Typeable b) => Typeable1 (tycon a b) where { \
-  typeOf1 = typeOf1Default }; \
-instance (Typeable a, Typeable b, Typeable c) => Typeable (tycon a b c) where { \
-  typeOf = typeOfDefault }
-
-#define INSTANCE_TYPEABLE4(tycon,tcname,str) \
-tcname = mkTyCon str; \
-instance Typeable4 tycon where { typeOf4 _ = mkTyConApp tcname [] }; \
-instance Typeable a => Typeable3 (tycon a) where { \
-  typeOf3 = typeOf3Default }; \
-instance (Typeable a, Typeable b) => Typeable2 (tycon a b) where { \
-  typeOf2 = typeOf2Default }; \
-instance (Typeable a, Typeable b, Typeable c) => Typeable1 (tycon a b c) where { \
-  typeOf1 = typeOf1Default }; \
-instance (Typeable a, Typeable b, Typeable c, Typeable d) => Typeable (tycon a b c d) where { \
-  typeOf = typeOfDefault }
-
-#define INSTANCE_TYPEABLE5(tycon,tcname,str) \
-tcname = mkTyCon str; \
-instance Typeable5 tycon where { typeOf5 _ = mkTyConApp tcname [] }; \
-instance Typeable a => Typeable4 (tycon a) where { \
-  typeOf4 = typeOf4Default }; \
-instance (Typeable a, Typeable b) => Typeable3 (tycon a b) where { \
-  typeOf3 = typeOf3Default }; \
-instance (Typeable a, Typeable b, Typeable c) => Typeable2 (tycon a b c) where { \
-  typeOf2 = typeOf2Default }; \
-instance (Typeable a, Typeable b, Typeable c, Typeable d) => Typeable1 (tycon a b c d) where { \
-  typeOf1 = typeOf1Default }; \
-instance (Typeable a, Typeable b, Typeable c, Typeable d, Typeable e) => Typeable (tycon a b c d e) where { \
-  typeOf = typeOfDefault }
-
-#define INSTANCE_TYPEABLE6(tycon,tcname,str) \
-tcname = mkTyCon str; \
-instance Typeable6 tycon where { typeOf6 _ = mkTyConApp tcname [] }; \
-instance Typeable a => Typeable5 (tycon a) where { \
-  typeOf5 = typeOf5Default }; \
-instance (Typeable a, Typeable b) => Typeable4 (tycon a b) where { \
-  typeOf4 = typeOf4Default }; \
-instance (Typeable a, Typeable b, Typeable c) => Typeable3 (tycon a b c) where { \
-  typeOf3 = typeOf3Default }; \
-instance (Typeable a, Typeable b, Typeable c, Typeable d) => Typeable2 (tycon a b c d) where { \
-  typeOf2 = typeOf2Default }; \
-instance (Typeable a, Typeable b, Typeable c, Typeable d, Typeable e) => Typeable1 (tycon a b c d e) where { \
-  typeOf1 = typeOf1Default }; \
-instance (Typeable a, Typeable b, Typeable c, Typeable d, Typeable e, Typeable f) => Typeable (tycon a b c d e f) where { \
-  typeOf = typeOfDefault }
-
-#define INSTANCE_TYPEABLE7(tycon,tcname,str) \
-tcname = mkTyCon str; \
-instance Typeable7 tycon where { typeOf7 _ = mkTyConApp tcname [] }; \
-instance Typeable a => Typeable6 (tycon a) where { \
-  typeOf6 = typeOf6Default }; \
-instance (Typeable a, Typeable b) => Typeable5 (tycon a b) where { \
-  typeOf5 = typeOf5Default }; \
-instance (Typeable a, Typeable b, Typeable c) => Typeable4 (tycon a b c) where { \
-  typeOf4 = typeOf4Default }; \
-instance (Typeable a, Typeable b, Typeable c, Typeable d) => Typeable3 (tycon a b c d) where { \
-  typeOf3 = typeOf3Default }; \
-instance (Typeable a, Typeable b, Typeable c, Typeable d, Typeable e) => Typeable2 (tycon a b c d e) where { \
-  typeOf2 = typeOf2Default }; \
-instance (Typeable a, Typeable b, Typeable c, Typeable d, Typeable e, Typeable f) => Typeable1 (tycon a b c d e f) where { \
-  typeOf1 = typeOf1Default }; \
-instance (Typeable a, Typeable b, Typeable c, Typeable d, Typeable e, Typeable f, Typeable g) => Typeable (tycon a b c d e f g) where { \
-  typeOf = typeOfDefault }
-
-#endif /* !__GLASGOW_HASKELL__ */
-
 #endif
index f8ea998..ae04142 100644 (file)
@@ -14,8 +14,6 @@
 #ifndef TYPEABLE_H
 #define TYPEABLE_H
 
-#ifdef __GLASGOW_HASKELL__
-
 --  // For GHC, we can use DeriveDataTypeable + StandaloneDeriving to
 --  // generate the instances.
 
 #define INSTANCE_TYPEABLE6(tycon,tcname,str) deriving instance Typeable tycon
 #define INSTANCE_TYPEABLE7(tycon,tcname,str) deriving instance Typeable tycon
 
-#else /* !__GLASGOW_HASKELL__ */
-
-#define INSTANCE_TYPEABLE0(tycon,tcname,str) \
-tcname :: TyCon; \
-tcname = mkTyCon str; \
-instance Typeable tycon where { typeOf _ = mkTyConApp tcname [] }
-
-#define INSTANCE_TYPEABLE1(tycon,tcname,str) \
-tcname = mkTyCon str; \
-instance Typeable1 tycon where { typeOf1 _ = mkTyConApp tcname [] }; \
-instance Typeable a => Typeable (tycon a) where { typeOf = typeOfDefault }
-
-#define INSTANCE_TYPEABLE2(tycon,tcname,str) \
-tcname = mkTyCon str; \
-instance Typeable2 tycon where { typeOf2 _ = mkTyConApp tcname [] }; \
-instance Typeable a => Typeable1 (tycon a) where { \
-  typeOf1 = typeOf1Default }; \
-instance (Typeable a, Typeable b) => Typeable (tycon a b) where { \
-  typeOf = typeOfDefault }
-
-#define INSTANCE_TYPEABLE3(tycon,tcname,str) \
-tcname = mkTyCon str; \
-instance Typeable3 tycon where { typeOf3 _ = mkTyConApp tcname [] }; \
-instance Typeable a => Typeable2 (tycon a) where { \
-  typeOf2 = typeOf2Default }; \
-instance (Typeable a, Typeable b) => Typeable1 (tycon a b) where { \
-  typeOf1 = typeOf1Default }; \
-instance (Typeable a, Typeable b, Typeable c) => Typeable (tycon a b c) where { \
-  typeOf = typeOfDefault }
-
-#define INSTANCE_TYPEABLE4(tycon,tcname,str) \
-tcname = mkTyCon str; \
-instance Typeable4 tycon where { typeOf4 _ = mkTyConApp tcname [] }; \
-instance Typeable a => Typeable3 (tycon a) where { \
-  typeOf3 = typeOf3Default }; \
-instance (Typeable a, Typeable b) => Typeable2 (tycon a b) where { \
-  typeOf2 = typeOf2Default }; \
-instance (Typeable a, Typeable b, Typeable c) => Typeable1 (tycon a b c) where { \
-  typeOf1 = typeOf1Default }; \
-instance (Typeable a, Typeable b, Typeable c, Typeable d) => Typeable (tycon a b c d) where { \
-  typeOf = typeOfDefault }
-
-#define INSTANCE_TYPEABLE5(tycon,tcname,str) \
-tcname = mkTyCon str; \
-instance Typeable5 tycon where { typeOf5 _ = mkTyConApp tcname [] }; \
-instance Typeable a => Typeable4 (tycon a) where { \
-  typeOf4 = typeOf4Default }; \
-instance (Typeable a, Typeable b) => Typeable3 (tycon a b) where { \
-  typeOf3 = typeOf3Default }; \
-instance (Typeable a, Typeable b, Typeable c) => Typeable2 (tycon a b c) where { \
-  typeOf2 = typeOf2Default }; \
-instance (Typeable a, Typeable b, Typeable c, Typeable d) => Typeable1 (tycon a b c d) where { \
-  typeOf1 = typeOf1Default }; \
-instance (Typeable a, Typeable b, Typeable c, Typeable d, Typeable e) => Typeable (tycon a b c d e) where { \
-  typeOf = typeOfDefault }
-
-#define INSTANCE_TYPEABLE6(tycon,tcname,str) \
-tcname = mkTyCon str; \
-instance Typeable6 tycon where { typeOf6 _ = mkTyConApp tcname [] }; \
-instance Typeable a => Typeable5 (tycon a) where { \
-  typeOf5 = typeOf5Default }; \
-instance (Typeable a, Typeable b) => Typeable4 (tycon a b) where { \
-  typeOf4 = typeOf4Default }; \
-instance (Typeable a, Typeable b, Typeable c) => Typeable3 (tycon a b c) where { \
-  typeOf3 = typeOf3Default }; \
-instance (Typeable a, Typeable b, Typeable c, Typeable d) => Typeable2 (tycon a b c d) where { \
-  typeOf2 = typeOf2Default }; \
-instance (Typeable a, Typeable b, Typeable c, Typeable d, Typeable e) => Typeable1 (tycon a b c d e) where { \
-  typeOf1 = typeOf1Default }; \
-instance (Typeable a, Typeable b, Typeable c, Typeable d, Typeable e, Typeable f) => Typeable (tycon a b c d e f) where { \
-  typeOf = typeOfDefault }
-
-#define INSTANCE_TYPEABLE7(tycon,tcname,str) \
-tcname = mkTyCon str; \
-instance Typeable7 tycon where { typeOf7 _ = mkTyConApp tcname [] }; \
-instance Typeable a => Typeable6 (tycon a) where { \
-  typeOf6 = typeOf6Default }; \
-instance (Typeable a, Typeable b) => Typeable5 (tycon a b) where { \
-  typeOf5 = typeOf5Default }; \
-instance (Typeable a, Typeable b, Typeable c) => Typeable4 (tycon a b c) where { \
-  typeOf4 = typeOf4Default }; \
-instance (Typeable a, Typeable b, Typeable c, Typeable d) => Typeable3 (tycon a b c d) where { \
-  typeOf3 = typeOf3Default }; \
-instance (Typeable a, Typeable b, Typeable c, Typeable d, Typeable e) => Typeable2 (tycon a b c d e) where { \
-  typeOf2 = typeOf2Default }; \
-instance (Typeable a, Typeable b, Typeable c, Typeable d, Typeable e, Typeable f) => Typeable1 (tycon a b c d e f) where { \
-  typeOf1 = typeOf1Default }; \
-instance (Typeable a, Typeable b, Typeable c, Typeable d, Typeable e, Typeable f, Typeable g) => Typeable (tycon a b c d e f g) where { \
-  typeOf = typeOfDefault }
-
-#endif /* !__GLASGOW_HASKELL__ */
-
 #endif
index d05068e..dc7313f 100644 (file)
@@ -1,4 +1,3 @@
-{-# LANGUAGE CPP #-}
 -- !!! Test seeking
 
 import System.IO
index 95b240d..0088c6e 100644 (file)
@@ -1,4 +1,3 @@
-{-# LANGUAGE CPP #-}
 import Control.Concurrent.QSem as OldQ
 
 import Control.Concurrent.Chan
index d45c09d..165efa5 100644 (file)
@@ -1,4 +1,3 @@
-{-# LANGUAGE CPP #-}
 import Control.Concurrent
 import Control.Exception
 import Control.Monad