Merge remote-tracking branch 'origin/master' into tc-untouchables

Conflicts:
	compiler/typecheck/TcMType.lhs
	compiler/typecheck/TcSMonad.lhs

1 files changed, 23 insertions, 23 deletions

diff --git a/compiler/main/BreakArray.hs b/compiler/main/BreakArray.hs
index 91e4c96c9a..4d3145fb3a 100644
--- a/compiler/main/BreakArray.hs
+++ b/compiler/main/BreakArray.hs
@@ -25,62 +25,62 @@ module BreakArray
 #endif
     ) where
 
+import DynFlags
+
 #ifdef GHCI
 import Control.Monad
 
 import GHC.Exts
 import GHC.IO ( IO(..) )
 
-import Constants
-
 data BreakArray = BA (MutableByteArray# RealWorld)
 
 breakOff, breakOn :: Word
 breakOn  = 1
 breakOff = 0
 
-showBreakArray :: BreakArray -> IO ()
-showBreakArray array = do
-    forM_ [0..(size array - 1)] $ \i -> do
+showBreakArray :: DynFlags -> BreakArray -> IO ()
+showBreakArray dflags array = do
+    forM_ [0 .. (size dflags array - 1)] $ \i -> do
         val <- readBreakArray array i
         putStr $ ' ' : show val
     putStr "\n"
 
-setBreakOn :: BreakArray -> Int -> IO Bool 
-setBreakOn array index
-    | safeIndex array index = do 
+setBreakOn :: DynFlags -> BreakArray -> Int -> IO Bool
+setBreakOn dflags array index
+    | safeIndex dflags array index = do
           writeBreakArray array index breakOn 
           return True
     | otherwise = return False 
 
-setBreakOff :: BreakArray -> Int -> IO Bool 
-setBreakOff array index
-    | safeIndex array index = do
+setBreakOff :: DynFlags -> BreakArray -> Int -> IO Bool
+setBreakOff dflags array index
+    | safeIndex dflags array index = do
           writeBreakArray array index breakOff
           return True
     | otherwise = return False 
 
-getBreak :: BreakArray -> Int -> IO (Maybe Word)
-getBreak array index 
-    | safeIndex array index = do
+getBreak :: DynFlags -> BreakArray -> Int -> IO (Maybe Word)
+getBreak dflags array index
+    | safeIndex dflags array index = do
           val <- readBreakArray array index 
           return $ Just val 
     | otherwise = return Nothing
 
-safeIndex :: BreakArray -> Int -> Bool
-safeIndex array index = index < size array && index >= 0
+safeIndex :: DynFlags -> BreakArray -> Int -> Bool
+safeIndex dflags array index = index < size dflags array && index >= 0
 
-size :: BreakArray -> Int
-size (BA array) = (I# (sizeofMutableByteArray# array)) `div` wORD_SIZE
+size :: DynFlags -> BreakArray -> Int
+size dflags (BA array) = (I# (sizeofMutableByteArray# array)) `div` wORD_SIZE dflags
 
 allocBA :: Int -> IO BreakArray 
 allocBA (I# sz) = IO $ \s1 ->
     case newByteArray# sz s1 of { (# s2, array #) -> (# s2, BA array #) }
 
 -- create a new break array and initialise elements to zero
-newBreakArray :: Int -> IO BreakArray
-newBreakArray entries@(I# sz) = do
-    BA array <- allocBA (entries * wORD_SIZE) 
+newBreakArray :: DynFlags -> Int -> IO BreakArray
+newBreakArray dflags entries@(I# sz) = do
+    BA array <- allocBA (entries * wORD_SIZE dflags)
     case breakOff of 
         W# off -> do    -- Todo: there must be a better way to write zero as a Word!
             let loop n | n ==# sz = return ()
@@ -112,8 +112,8 @@ readBreakArray (BA array) (I# i) = readBA# array i
 -- presumably have a different representation.
 data BreakArray = Unspecified
 
-newBreakArray :: Int -> IO BreakArray
-newBreakArray _ = return Unspecified
+newBreakArray :: DynFlags -> Int -> IO BreakArray
+newBreakArray _ _ = return Unspecified
 
 #endif /* GHCI */