SafeHaskell: Update to work with safe base
authorDavid Terei <davidterei@gmail.com>
Thu, 19 May 2011 07:57:12 +0000 (00:57 -0700)
committerDavid Terei <davidterei@gmail.com>
Sat, 18 Jun 2011 03:39:56 +0000 (20:39 -0700)
12 files changed:
compiler/basicTypes/UniqSupply.lhs
compiler/ghc.cabal.in
compiler/ghci/ByteCodeLink.lhs
compiler/ghci/RtClosureInspect.hs
compiler/main/BreakArray.hs
compiler/prelude/PrelNames.lhs
compiler/utils/Binary.hs
compiler/utils/Encoding.hs
compiler/utils/FastFunctions.lhs
compiler/utils/FastMutInt.lhs
compiler/utils/FastString.lhs
compiler/utils/GhcIO.hs [new file with mode: 0644]

index 493bfbe..4e1de6a 100644 (file)
@@ -29,9 +29,10 @@ module UniqSupply (
 import Unique
 import FastTypes
 
+import GhcIO (unsafeDupableInterleaveIO)
+
 import MonadUtils
 import Control.Monad
-import GHC.IO (unsafeDupableInterleaveIO)
 
 \end{code}
 
index 2711c1b..7fffe83 100644 (file)
@@ -435,6 +435,7 @@ Library
         FastTypes
         Fingerprint
         FiniteMap
+        GhcIO
         GraphBase
         GraphColor
         GraphOps
index b1f7e39..7fdc274 100644 (file)
@@ -38,19 +38,18 @@ import Panic
 import Outputable
 
 -- Standard libraries
-import GHC.Word                ( Word(..) )
 
 import Data.Array.Base
-import GHC.Arr         ( STArray(..) )
 
 import Control.Monad   ( zipWithM )
 import Control.Monad.ST ( stToIO )
 
-import GHC.Exts
-import GHC.Arr         ( Array(..) )
+import GHC.Arr.Unsafe   ( Array(..), STArray(..) )
+import GHC.Base                ( writeArray#, RealWorld, Int(..), Word# )  
 import GHC.IOBase      ( IO(..) )
+import GHC.Exts
 import GHC.Ptr         ( Ptr(..), castPtr )
-import GHC.Base                ( writeArray#, RealWorld, Int(..), Word# )  
+import GHC.Word                ( Word(..) )
 
 import Data.Word
 \end{code}
index b6c97c3..0b4d031 100644 (file)
@@ -53,9 +53,9 @@ import DynFlags
 import Outputable as Ppr
 import FastString
 import Constants        ( wORD_SIZE )
-import GHC.Arr          ( Array(..) )
+import GHC.Arr.Unsafe   ( Array(..) )
 import GHC.Exts
-import GHC.IO ( IO(..) )
+import GhcIO ( IO(..) )
 
 import StaticFlags( opt_PprStyle_Debug )
 import Control.Monad
index 4d2c07b..29d7d77 100644 (file)
@@ -26,7 +26,7 @@ module BreakArray
   ) where
 #ifdef GHCI
 import GHC.Exts
-import GHC.IO ( IO(..) )
+import GhcIO ( IO(..) )
 import Constants
 
 data BreakArray = BA (MutableByteArray# RealWorld)
index 4fd23ee..0c06336 100644 (file)
@@ -314,9 +314,9 @@ gHC_CONC    = mkBaseModule (fsLit "GHC.Conc")
 gHC_IO         = mkBaseModule (fsLit "GHC.IO")
 gHC_IO_Exception = mkBaseModule (fsLit "GHC.IO.Exception")
 gHC_ST         = mkBaseModule (fsLit "GHC.ST")
-gHC_ARR                = mkBaseModule (fsLit "GHC.Arr")
+gHC_ARR                = mkBaseModule (fsLit "GHC.Arr.Imp")
 gHC_STABLE     = mkBaseModule (fsLit "GHC.Stable")
-gHC_PTR                = mkBaseModule (fsLit "GHC.Ptr")
+gHC_PTR                = mkBaseModule (fsLit "GHC.Ptr.Imp")
 gHC_ERR                = mkBaseModule (fsLit "GHC.Err")
 gHC_REAL       = mkBaseModule (fsLit "GHC.Real")
 gHC_FLOAT      = mkBaseModule (fsLit "GHC.Float")
index 1981dc8..80e9171 100644 (file)
@@ -81,7 +81,8 @@ import System.IO.Error          ( mkIOError, eofErrorType )
 import GHC.Real                 ( Ratio(..) )
 import GHC.Exts
 import GHC.Word                 ( Word8(..) )
-import GHC.IO ( IO(..) )
+
+import GhcIO ( IO(..) )
 
 type BinArray = ForeignPtr Word8
 
index 84b4e09..4351538 100644 (file)
@@ -32,7 +32,11 @@ module Encoding (
 import Foreign
 import Data.Char
 import Numeric
+#if __GLASGOW_HASKELL__ >= 701
+import GHC.Ptr.Unsafe   ( Ptr(..) )
+#else
 import GHC.Ptr          ( Ptr(..) )
+#endif
 import GHC.Base
 
 -- -----------------------------------------------------------------------------
index 5496ed0..0734240 100644 (file)
@@ -22,9 +22,10 @@ import System.IO.Unsafe
 
 import GHC.Exts
 import GHC.Word
-import GHC.IO (IO(..), unsafeDupableInterleaveIO)
 import GHC.Base (unsafeChr)
 
+import GhcIO        (IO(..), unsafeDupableInterleaveIO)
+
 -- Just like unsafePerformIO, but we inline it.
 {-# INLINE inlinePerformIO #-}
 inlinePerformIO :: IO a -> a
index 2618307..8f7de90 100644 (file)
@@ -26,7 +26,11 @@ module FastMutInt(
 #endif
 
 import GHC.Base
-import GHC.Ptr
+#if __GLASGOW_HASKELL__ >= 701
+import GHC.Ptr.Unsafe   ( Ptr(..) )
+#else
+import GHC.Ptr          ( Ptr(..) )
+#endif
 
 #else /* ! __GLASGOW_HASKELL__ */
 
index c6dac8f..55b115c 100644 (file)
@@ -106,7 +106,7 @@ import Data.IORef       ( IORef, newIORef, readIORef, writeIORef )
 import Data.Maybe       ( isJust )
 import Data.Char        ( ord )
 
-import GHC.IO ( IO(..) )
+import GhcIO ( IO(..) )
 
 import GHC.Ptr          ( Ptr(..) )
 #if defined(__GLASGOW_HASKELL__)
diff --git a/compiler/utils/GhcIO.hs b/compiler/utils/GhcIO.hs
new file mode 100644 (file)
index 0000000..9d6734e
--- /dev/null
@@ -0,0 +1,16 @@
+-- | A simple version compatability wrapper around GHC.IO.
+-- This module exports both the safe and Unsafe version of GHC.IO
+-- after that SafeHaskell change over occured.
+module GhcIO (
+#if __GLASGOW_HASKELL__ >= 701
+        module GHC.IO.Unsafe,
+#endif
+        module GHC.IO
+    ) where
+
+#if __GLASGOW_HASKELL__ >= 701
+import GHC.IO.Unsafe
+#endif
+
+import GHC.IO
+