Ticket #3693: Base-StackTraces.dpatch

File Base-StackTraces.dpatch, 48.2 KB (added by batterseapower, 4 years ago)
Line 
14 patches for repository /Users/mbolingbroke/Programming/Checkouts/ghc.head/libraries/base:
2
3Thu Apr 22 11:14:52 BST 2010  Max Bolingbroke <batterseapower@hotmail.com>
4  * Stack trace support
5
6Mon Apr 26 23:09:04 BST 2010  Max Bolingbroke <batterseapower@hotmail.com>
7  * Support for STG stack traces in the base library
8
9Tue Apr 27 10:46:33 BST 2010  Max Bolingbroke <batterseapower@hotmail.com>
10  * Slight tweak to formatting of stack traces produced by stack overflow
11
12Thu Apr 29 15:30:41 BST 2010  Max Bolingbroke <batterseapower@hotmail.com>
13  * Move the StackTrace type synonym, export a convenient function for stack trace formatting
14
15New patches:
16
17[Stack trace support
18Max Bolingbroke <batterseapower@hotmail.com>**20100422101452
19 Ignore-this: 3aa10b136d43ee6e0a75dd887c8ec495
20] {
21hunk ./GHC/Conc.lhs 97
22         , setUncaughtExceptionHandler      -- :: (Exception -> IO ()) -> IO ()
23         , getUncaughtExceptionHandler      -- :: IO (Exception -> IO ())
24 
25-        , reportError, reportStackOverflow
26+        , reportError, reportStackOverflow, reportStack
27         ) where
28 
29 import System.Posix.Types
30hunk ./GHC/Conc.lhs 116
31 #endif
32 import Control.Monad
33 import Data.Maybe
34+import Data.List (init, unlines)
35 
36 import GHC.Base
37 #ifndef mingw32_HOST_OS
38hunk ./GHC/Conc.lhs 1312
39 
40 #endif
41 
42+-- TODO: replace this with an implementation that calls into the RTS?
43+reportStack :: [String] -> IO ()
44+reportStack stk = do
45+  (hFlush stdout) `catchAny` (\ _ -> return ())
46+  withCString "%s" $ \cfmt ->
47+    withCString (init $ unlines $ "Backtrace:" : map (\x -> ' ':' ':x) stk) $ \cmsg ->
48+      errorBelch cfmt cmsg
49+
50 reportStackOverflow :: IO ()
51 reportStackOverflow = callStackOverflowHook
52 
53hunk ./GHC/Exts.hs 47
54         Down(..), groupWith, sortWith, the,
55 
56         -- * Event logging
57-        traceEvent
58+        traceEvent,
59 
60        ) where
61 
62hunk ./GHC/IO.hs 29
63 
64     FilePath,
65 
66-    catchException, catchAny, throwIO,
67+    catchException, catchExceptionWithStack,
68+    catchAny, catchAnyWithStack,
69+    throwIO,
70     block, unblock, blocked,
71     onException, finally, evaluate
72   ) where
73hunk ./GHC/IO.hs 43
74 
75 import {-# SOURCE #-} GHC.IO.Exception ( userError )
76 
77+#include "MachDeps.h"
78+#include "HsBaseConfig.h"
79+
80 -- ---------------------------------------------------------------------------
81 -- The IO Monad
82 
83hunk ./GHC/IO.hs 244
84 
85 Now catch# has type
86 
87-    catch# :: IO a -> (b -> IO a) -> IO a
88+    catch# :: IO a -> (b -> ByteArray# {- reified stack -} -> IO a) -> IO a
89 
90 (well almost; the compiler doesn't know about the IO newtype so we
91 have to work around that in the definition of catchException below).
92hunk ./GHC/IO.hs 251
93 -}
94 
95 catchException :: Exception e => IO a -> (e -> IO a) -> IO a
96-catchException (IO io) handler = IO $ catch# io handler'
97-    where handler' e = case fromException e of
98-                       Just e' -> unIO (handler e')
99-                       Nothing -> raise# e
100+catchException io handler = catchExceptionWithStack io handler'
101+    where handler' e _stk = handler e
102+
103+catchExceptionWithStack :: Exception e => IO a -> (e -> [String] -> IO a) -> IO a
104+catchExceptionWithStack (IO io) handler = IO $ catch# io handler'
105+    where handler' e stk = case fromException e of
106+                       Just e' -> unIO (handler e' (reifyStack stk))
107+                       Nothing -> raiseWithStack# e stk
108 
109 catchAny :: IO a -> (forall e . Exception e => e -> IO a) -> IO a
110hunk ./GHC/IO.hs 261
111-catchAny (IO io) handler = IO $ catch# io handler'
112-    where handler' (SomeException e) = unIO (handler e)
113+catchAny io handler = catchAnyWithStack io handler'
114+    where handler' e _stk = handler e
115+
116+catchAnyWithStack :: IO a -> (forall e . Exception e => e -> [String] -> IO a) -> IO a
117+catchAnyWithStack (IO io) handler = IO $ catch# io handler'
118+    where
119+      handler' (SomeException e) stk = unIO (handler e (reifyStack stk))
120+
121+reifyStack :: ByteArray# -> [String]
122+reifyStack ba = go 0#
123+  where
124+    !last_i = sizeofByteArray# ba `quotInt#` SIZEOF_HSPTR#
125+    go i | i ==# last_i = []
126+         | otherwise    = unpackCStringUtf8# (indexAddrArray# ba i) : go (i +# 1#)
127 
128 -- | A variant of 'throw' that can only be used within the 'IO' monad.
129 --
130hunk ./GHC/TopHandler.lhs 66
131       a <- main
132       cleanUp
133       return a
134-    `catch`
135+    `catchExceptionWithStack`
136       topHandler
137 
138 install_interrupt_handler :: IO () -> IO ()
139hunk ./GHC/TopHandler.lhs 115
140 -- program.
141 --
142 runIO :: IO a -> IO a
143-runIO main = catch main topHandler
144+runIO main = catchExceptionWithStack main topHandler
145 
146 -- | Like 'runIO', but in the event of an exception that causes an exit,
147 -- we don't shut down the system cleanly, we just exit.  This is
148hunk ./GHC/TopHandler.lhs 130
149 -- safeExit.  There is a race to shut down between the main and child threads.
150 --
151 runIOFastExit :: IO a -> IO a
152-runIOFastExit main = catch main topHandlerFastExit
153+runIOFastExit main = catchExceptionWithStack main topHandlerFastExit
154         -- NB. this is used by the testsuite driver
155 
156 -- | The same as 'runIO', but for non-IO computations.  Used for
157hunk ./GHC/TopHandler.lhs 138
158 -- are used to export Haskell functions with non-IO types.
159 --
160 runNonIO :: a -> IO a
161-runNonIO a = catch (a `seq` return a) topHandler
162+runNonIO a = catchExceptionWithStack (a `seq` return a) topHandler
163 
164hunk ./GHC/TopHandler.lhs 140
165-topHandler :: SomeException -> IO a
166-topHandler err = catch (real_handler safeExit err) topHandler
167+topHandler :: SomeException -> [String] -> IO a
168+topHandler err stk = catchExceptionWithStack (real_handler safeExit err stk) topHandler
169 
170hunk ./GHC/TopHandler.lhs 143
171-topHandlerFastExit :: SomeException -> IO a
172-topHandlerFastExit err =
173-  catchException (real_handler fastExit err) topHandlerFastExit
174+topHandlerFastExit :: SomeException -> [String] -> IO a
175+topHandlerFastExit err stk =
176+  catchExceptionWithStack (real_handler fastExit err stk) topHandlerFastExit
177 
178 -- Make sure we handle errors while reporting the error!
179 -- (e.g. evaluating the string passed to 'error' might generate
180hunk ./GHC/TopHandler.lhs 151
181 --  another error, etc.)
182 --
183-real_handler :: (Int -> IO a) -> SomeException -> IO a
184-real_handler exit se@(SomeException exn) =
185+real_handler :: (Int -> IO a) -> SomeException -> [String] -> IO a
186+real_handler exit se@(SomeException exn) stk =
187   cleanUp >>
188   case cast exn of
189       Just StackOverflow -> do
190hunk ./GHC/TopHandler.lhs 157
191            reportStackOverflow
192+           reportStack stk
193            exit 2
194 
195       Just UserInterrupt  -> exitInterrupted
196hunk ./GHC/TopHandler.lhs 174
197                               ioe_handle = Just hdl }
198                    | Errno ioe == ePIPE, hdl == stdout -> exit 0
199                 _ -> do reportError se
200+                        reportStack stk
201                         exit 1
202           
203 
204}
205[Support for STG stack traces in the base library
206Max Bolingbroke <batterseapower@hotmail.com>**20100426220904
207 Ignore-this: b3887eadb761cd42cd6487334f75b0f4
208] {
209hunk ./Control/Concurrent.hs 103
210 import GHC.Conc         ( ThreadId(..), myThreadId, killThread, yield,
211                           threadDelay, forkIO, childHandler )
212 import qualified GHC.Conc
213-import GHC.IO           ( IO(..), unsafeInterleaveIO )
214+import GHC.IO           ( IO(..), unsafeInterleaveIO, catchExceptionWithStack )
215 import GHC.IORef        ( newIORef, readIORef, writeIORef )
216 import GHC.Base
217 
218hunk ./Control/Concurrent.hs 368
219             action1 | b = action0
220                     | otherwise = unblock action0
221 
222-            action_plus = Exception.catch action1 childHandler
223+            action_plus = catchExceptionWithStack action1 childHandler
224 
225         entry <- newStablePtr (myThreadId >>= putMVar mv >> action_plus)
226         err <- forkOS_createThread entry
227hunk ./GHC/Conc.lhs 34
228         , forkIO        -- :: IO a -> IO ThreadId
229         , forkOnIO      -- :: Int -> IO a -> IO ThreadId
230         , numCapabilities -- :: Int
231-        , childHandler  -- :: Exception -> IO ()
232+        , childHandler  -- :: Exception -> StackTrace -> IO ()
233         , myThreadId    -- :: IO ThreadId
234         , killThread    -- :: ThreadId -> IO ()
235         , throwTo       -- :: ThreadId -> Exception -> IO ()
236hunk ./GHC/Conc.lhs 94
237         , win32ConsoleHandler
238         , toWin32ConsoleEvent
239 #endif
240-        , setUncaughtExceptionHandler      -- :: (Exception -> IO ()) -> IO ()
241-        , getUncaughtExceptionHandler      -- :: IO (Exception -> IO ())
242+        -- * Stack traces and error reporting
243+        , StackTrace
244 
245hunk ./GHC/Conc.lhs 97
246-        , reportError, reportStackOverflow, reportStack
247+        , setUncaughtExceptionHandler      -- :: (Exception -> StackTrace -> IO ()) -> IO ()
248+        , getUncaughtExceptionHandler      -- :: IO (Exception -> StackTrace -> IO ())
249+
250+        , reportError, reportStackOverflow
251         ) where
252 
253 import System.Posix.Types
254hunk ./GHC/Conc.lhs 119
255 #endif
256 import Control.Monad
257 import Data.Maybe
258-import Data.List (init, unlines)
259+import Data.List (init, unlines, null)
260 
261 import GHC.Base
262 #ifndef mingw32_HOST_OS
263hunk ./GHC/Conc.lhs 230
264 forkIO action = IO $ \ s ->
265    case (fork# action_plus s) of (# s1, tid #) -> (# s1, ThreadId tid #)
266  where
267-  action_plus = catchException action childHandler
268+  action_plus = catchExceptionWithStack action childHandler
269 
270 {- |
271 Like 'forkIO', but lets you specify on which CPU the thread is
272hunk ./GHC/Conc.lhs 249
273 forkOnIO (I# cpu) action = IO $ \ s ->
274    case (forkOn# cpu action_plus s) of (# s1, tid #) -> (# s1, ThreadId tid #)
275  where
276-  action_plus = catchException action childHandler
277+  action_plus = catchExceptionWithStack action childHandler
278 
279 -- | the value passed to the @+RTS -N@ flag.  This is the number of
280 -- Haskell threads that can run truly simultaneously at any given
281hunk ./GHC/Conc.lhs 265
282 #else
283 foreign import ccall "&n_capabilities" n_capabilities :: Ptr CInt
284 #endif
285-childHandler :: SomeException -> IO ()
286-childHandler err = catchException (real_handler err) childHandler
287+childHandler :: SomeException -> StackTrace -> IO ()
288+childHandler err stk = catchExceptionWithStack (real_handler err stk) childHandler
289 
290hunk ./GHC/Conc.lhs 268
291-real_handler :: SomeException -> IO ()
292-real_handler se@(SomeException ex) =
293+real_handler :: SomeException -> StackTrace -> IO ()
294+real_handler se@(SomeException ex) stk =
295   -- ignore thread GC and killThread exceptions:
296   case cast ex of
297   Just BlockedIndefinitelyOnMVar        -> return ()
298hunk ./GHC/Conc.lhs 279
299             Just ThreadKilled           -> return ()
300             _ -> case cast ex of
301                  -- report all others:
302-                 Just StackOverflow     -> reportStackOverflow
303-                 _                      -> reportError se
304+                 Just StackOverflow     -> reportStackOverflow stk
305+                 _                      -> reportError se stk
306 
307 {- | 'killThread' terminates the given thread (GHC only).
308 Any work already done by the thread isn\'t
309hunk ./GHC/Conc.lhs 1315
310 
311 #endif
312 
313--- TODO: replace this with an implementation that calls into the RTS?
314-reportStack :: [String] -> IO ()
315-reportStack stk = do
316-  (hFlush stdout) `catchAny` (\ _ -> return ())
317-  withCString "%s" $ \cfmt ->
318-    withCString (init $ unlines $ "Backtrace:" : map (\x -> ' ':' ':x) stk) $ \cmsg ->
319-      errorBelch cfmt cmsg
320+type StackTrace = [String]
321+
322+foreign import ccall unsafe "rtsShowsStackTraces" showStackTraces :: Bool
323+
324+formatStackTraceSuffix :: StackTrace -> String
325+formatStackTraceSuffix []  = ""
326+formatStackTraceSuffix stk = init $ unlines $ "\nSTG stack:" : (map (\x -> ' ':' ':x) stk)
327 
328hunk ./GHC/Conc.lhs 1323
329-reportStackOverflow :: IO ()
330-reportStackOverflow = callStackOverflowHook
331+reportStackOverflow :: StackTrace -> IO ()
332+reportStackOverflow stk = do
333+  callStackOverflowHook
334+  when (showStackTraces && not (null stk)) $ do
335+    (hFlush stdout) `catchAny` (\ _ -> return ())
336+    -- TODO: better formatting? TODO: move into RTS?
337+    withCString "%s" $ \cfmt ->
338+      withCString (formatStackTraceSuffix stk) $ \cmsg ->
339+        errorBelch cfmt cmsg
340 
341hunk ./GHC/Conc.lhs 1333
342-reportError :: SomeException -> IO ()
343-reportError ex = do
344+reportError :: SomeException -> StackTrace -> IO ()
345+reportError ex stk = do
346    handler <- getUncaughtExceptionHandler
347hunk ./GHC/Conc.lhs 1336
348-   handler ex
349+   handler ex stk
350 
351 -- SUP: Are the hooks allowed to re-enter Haskell land?  If so, remove
352 -- the unsafe below.
353hunk ./GHC/Conc.lhs 1344
354         callStackOverflowHook :: IO ()
355 
356 {-# NOINLINE uncaughtExceptionHandler #-}
357-uncaughtExceptionHandler :: IORef (SomeException -> IO ())
358+uncaughtExceptionHandler :: IORef (SomeException -> StackTrace -> IO ())
359 uncaughtExceptionHandler = unsafePerformIO (newIORef defaultHandler)
360    where
361hunk ./GHC/Conc.lhs 1347
362-      defaultHandler :: SomeException -> IO ()
363-      defaultHandler se@(SomeException ex) = do
364+      defaultHandler :: SomeException -> StackTrace -> IO ()
365+      defaultHandler se@(SomeException ex) stk = do
366          (hFlush stdout) `catchAny` (\ _ -> return ())
367          let msg = case cast ex of
368                Just Deadlock -> "no threads to run:  infinite loop or deadlock?"
369hunk ./GHC/Conc.lhs 1356
370                     Just (ErrorCall s) -> s
371                     _                  -> showsPrec 0 se ""
372          withCString "%s" $ \cfmt ->
373-          withCString msg $ \cmsg ->
374+          withCString (if showStackTraces then msg ++ formatStackTraceSuffix stk else msg) $ \cmsg ->
375             errorBelch cfmt cmsg
376 
377 -- don't use errorBelch() directly, because we cannot call varargs functions
378hunk ./GHC/Conc.lhs 1364
379 foreign import ccall unsafe "HsBase.h errorBelch2"
380    errorBelch :: CString -> CString -> IO ()
381 
382-setUncaughtExceptionHandler :: (SomeException -> IO ()) -> IO ()
383+setUncaughtExceptionHandler :: (SomeException -> StackTrace -> IO ()) -> IO ()
384 setUncaughtExceptionHandler = writeIORef uncaughtExceptionHandler
385 
386hunk ./GHC/Conc.lhs 1367
387-getUncaughtExceptionHandler :: IO (SomeException -> IO ())
388+getUncaughtExceptionHandler :: IO (SomeException -> StackTrace -> IO ())
389 getUncaughtExceptionHandler = readIORef uncaughtExceptionHandler
390 
391 \end{code}
392hunk ./GHC/TopHandler.lhs 140
393 runNonIO :: a -> IO a
394 runNonIO a = catchExceptionWithStack (a `seq` return a) topHandler
395 
396-topHandler :: SomeException -> [String] -> IO a
397+topHandler :: SomeException -> StackTrace -> IO a
398 topHandler err stk = catchExceptionWithStack (real_handler safeExit err stk) topHandler
399 
400hunk ./GHC/TopHandler.lhs 143
401-topHandlerFastExit :: SomeException -> [String] -> IO a
402+topHandlerFastExit :: SomeException -> StackTrace -> IO a
403 topHandlerFastExit err stk =
404   catchExceptionWithStack (real_handler fastExit err stk) topHandlerFastExit
405 
406hunk ./GHC/TopHandler.lhs 151
407 -- (e.g. evaluating the string passed to 'error' might generate
408 --  another error, etc.)
409 --
410-real_handler :: (Int -> IO a) -> SomeException -> [String] -> IO a
411+real_handler :: (Int -> IO a) -> SomeException -> StackTrace -> IO a
412 real_handler exit se@(SomeException exn) stk =
413   cleanUp >>
414   case cast exn of
415hunk ./GHC/TopHandler.lhs 156
416       Just StackOverflow -> do
417-           reportStackOverflow
418-           reportStack stk
419+           reportStackOverflow stk
420            exit 2
421 
422       Just UserInterrupt  -> exitInterrupted
423hunk ./GHC/TopHandler.lhs 172
424                               ioe_errno = Just ioe,
425                               ioe_handle = Just hdl }
426                    | Errno ioe == ePIPE, hdl == stdout -> exit 0
427-                _ -> do reportError se
428-                        reportStack stk
429+                _ -> do reportError se stk
430                         exit 1
431           
432 
433}
434[Slight tweak to formatting of stack traces produced by stack overflow
435Max Bolingbroke <batterseapower@hotmail.com>**20100427094633
436 Ignore-this: 30d83357ed8851d4bf74896baf5c9932
437] {
438hunk ./GHC/Conc.lhs 119
439 #endif
440 import Control.Monad
441 import Data.Maybe
442-import Data.List (init, unlines, null)
443+import Data.List (drop, init, unlines, null)
444 
445 import GHC.Base
446 #ifndef mingw32_HOST_OS
447hunk ./GHC/Conc.lhs 1330
448     (hFlush stdout) `catchAny` (\ _ -> return ())
449     -- TODO: better formatting? TODO: move into RTS?
450     withCString "%s" $ \cfmt ->
451-      withCString (formatStackTraceSuffix stk) $ \cmsg ->
452+      withCString (drop 1 $ formatStackTraceSuffix stk) $ \cmsg ->
453         errorBelch cfmt cmsg
454 
455 reportError :: SomeException -> StackTrace -> IO ()
456}
457[Move the StackTrace type synonym, export a convenient function for stack trace formatting
458Max Bolingbroke <batterseapower@hotmail.com>**20100429143041
459 Ignore-this: 2841946ccdad7d0ad8860740a9780329
460] {
461hunk ./GHC/Conc.lhs 95
462         , toWin32ConsoleEvent
463 #endif
464         -- * Stack traces and error reporting
465-        , StackTrace
466-
467         , setUncaughtExceptionHandler      -- :: (Exception -> StackTrace -> IO ()) -> IO ()
468         , getUncaughtExceptionHandler      -- :: IO (Exception -> StackTrace -> IO ())
469 
470hunk ./GHC/Conc.lhs 98
471-        , reportError, reportStackOverflow
472+        , reportError, reportStackOverflow, formatStackTraceSuffix
473         ) where
474 
475 import System.Posix.Types
476hunk ./GHC/Conc.lhs 1313
477 
478 #endif
479 
480-type StackTrace = [String]
481-
482 foreign import ccall unsafe "rtsShowsStackTraces" showStackTraces :: Bool
483 
484 formatStackTraceSuffix :: StackTrace -> String
485hunk ./GHC/IO.hs 28
486     stToIO, ioToST, unsafeIOToST, unsafeSTToIO,
487 
488     FilePath,
489-
490+   
491+    StackTrace,
492     catchException, catchExceptionWithStack,
493     catchAny, catchAnyWithStack,
494     throwIO,
495hunk ./GHC/IO.hs 251
496 have to work around that in the definition of catchException below).
497 -}
498 
499+-- | The type of stack traces produced by 'catchExceptionWithStack' and friends.
500+type StackTrace = [String]
501+
502 catchException :: Exception e => IO a -> (e -> IO a) -> IO a
503 catchException io handler = catchExceptionWithStack io handler'
504     where handler' e _stk = handler e
505hunk ./GHC/IO.hs 258
506 
507-catchExceptionWithStack :: Exception e => IO a -> (e -> [String] -> IO a) -> IO a
508+catchExceptionWithStack :: Exception e => IO a -> (e -> StackTrace -> IO a) -> IO a
509 catchExceptionWithStack (IO io) handler = IO $ catch# io handler'
510     where handler' e stk = case fromException e of
511                        Just e' -> unIO (handler e' (reifyStack stk))
512hunk ./GHC/IO.hs 268
513 catchAny io handler = catchAnyWithStack io handler'
514     where handler' e _stk = handler e
515 
516-catchAnyWithStack :: IO a -> (forall e . Exception e => e -> [String] -> IO a) -> IO a
517+catchAnyWithStack :: IO a -> (forall e . Exception e => e -> StackTrace -> IO a) -> IO a
518 catchAnyWithStack (IO io) handler = IO $ catch# io handler'
519     where
520       handler' (SomeException e) stk = unIO (handler e (reifyStack stk))
521hunk ./GHC/IO.hs 273
522 
523-reifyStack :: ByteArray# -> [String]
524+reifyStack :: ByteArray# -> StackTrace
525 reifyStack ba = go 0#
526   where
527     !last_i = sizeofByteArray# ba `quotInt#` SIZEOF_HSPTR#
528}
529
530Context:
531
532[inline allocaArray0, to fix withCString benchmark
533Simon Marlow <marlowsd@gmail.com>**20100423124729
534 Ignore-this: 35c96816acc2f3aaf9dd29f7995fa6f0
535]
536[raise asynchronous exceptions asynchronously (#3997)
537Simon Marlow <marlowsd@gmail.com>**20100421094932
538 Ignore-this: 6d987d93d382c0f69c68c326312abd6b
539]
540[add NOINLINE pragmas for stdin/stdout/stderr
541Simon Marlow <marlowsd@gmail.com>**20100421082041
542 Ignore-this: 3fc130268ec786f28d945858d6690986
543]
544[INLINE alloca and malloc
545Simon Marlow <marlowsd@gmail.com>**20100419135333
546 Ignore-this: b218bd611f18721b1505a8c0b9e6a16a
547 See discussion on glasgow-haskell-users:
548   http://www.haskell.org/pipermail/glasgow-haskell-users/2010-April/018740.html
549]
550[Move comment closer to the offending line
551Matthias Kilian <kili@outback.escape.de>**20100419155421
552 Ignore-this: b34a1d7affd66f67d210df2377b585d9
553]
554[Ignore the return code of c_fcntl_write again
555Matthias Kilian <kili@outback.escape.de>**20100415140452
556 Ignore-this: 266d8ba02cc3cb79c85629b3528261c9
557 
558 The return code has been ignored in the past on purpose, because
559 O_NONBLOCK will fail on BSDs for some special files. This fixes the
560 problem mentioned in
561 http://www.haskell.org/pipermail/glasgow-haskell-users/2010-April/018698.html
562 
563]
564[Fix bitrot in IO debugging code
565Ian Lynagh <igloo@earth.li>**20100413134339
566 Also switched to using Haskell Bools (rather than CPP) to en/disable it,
567 so it shouldn't break again in the future.
568]
569[Tiny code tidy-up
570Ian Lynagh <igloo@earth.li>**20100413011147]
571[remove old/wrong comment
572Simon Marlow <marlowsd@gmail.com>**20100325161403
573 Ignore-this: e6e377d44af48c4162d17d55bdf3f821
574]
575[withThread: block asynchronous exceptions before installing exception handler.
576Bas van Dijk <v.dijk.bas@gmail.com>**20100329131624
577 Ignore-this: be5aeb47dbd73807b5f94df11afbb81c
578 Note that I don't unblock the given io computation. Because AFAICS
579 withThread is only called with 'waitFd' which only performs an FFI
580 call which can't receive asynchronous exceptions anyway.
581]
582[runInUnboundThread: block asynchronous exceptions before installing exception handler
583Bas van Dijk <v.dijk.bas@gmail.com>**20100329131549
584 Ignore-this: a00c5e32fe3981ff87bedd367a69051e
585]
586[fix the deprecation message (GHC.IO.Handle.Base -> GHC.IO.Handle)
587Simon Marlow <marlowsd@gmail.com>**20100330121137
588 Ignore-this: 4ca8500a01ac93454507aa8f9dd001f9
589]
590[Make SampleVar an abstract newtype
591Bas van Dijk <v.dijk.bas@gmail.com>**20100318200349
592 Ignore-this: 27939e2a064b75e71cb146117346be30
593]
594[Fix bugs regarding asynchronous exceptions and laziness in Control.Concurrent.SampleVar
595Bas van Dijk <v.dijk.bas@gmail.com>**20100318200104
596 Ignore-this: 7376b2a3afe155daf233a8f1ddc0a7a
597  - Block asynchronous exceptions at the right places
598  - Force thunks before putting them in a MVar
599]
600[Write the thunk 'next' to the MVar
601Bas van Dijk <v.dijk.bas@gmail.com>**20100319125951
602 Ignore-this: dd25636cf220131385ff2fd32493d456
603]
604[change to use STM, fixing 4 things
605Simon Marlow <marlowsd@gmail.com>**20100318104436
606 Ignore-this: 551d30280a7941c08f5c3b14576bdd70
607   1. there was no async exception protection
608   2. there was a space leak (now new value is strict)
609   3. using atomicModifyIORef would be slightly quicker, but can
610      suffer from adverse scheduling issues (see #3838)
611   4. also, the STM version is faster.
612]
613[Tweak docs
614Ian Lynagh <igloo@earth.li>**20100312214129]
615[Fixed dead links in documentation of forkIO
616Bas van Dijk <v.dijk.bas@gmail.com>**20100308222415
617 Ignore-this: 7deb8fd064c867fbede2a6b2e9da4f15
618]
619[Documentation fixes in Control.Exception
620Bas van Dijk <v.dijk.bas@gmail.com>**20100301220442
621 Ignore-this: 761fcba401cbd1f47276ddfc9b5b80f2
622]
623[Plug two race conditions that could lead to deadlocks in the IO manager
624Simon Marlow <marlowsd@gmail.com>**20100225120255
625 Ignore-this: e6983d6b953104d370278ab3e4617e8b
626]
627[FIX #3866: improve documentation of Data.Data.Constr
628jpm@cs.uu.nl**20100224125506
629 Ignore-this: 3818c5d8fee012a3cf322fb455b6e5dc
630]
631[UNDO: Handle NaN, -Infinity and Infinity in the toRational for Float/Double (#3676)
632Simon Marlow <marlowsd@gmail.com>**20100223101603
633 Ignore-this: 78becb2d39b3cd9a1a473a5811ca7d92
634]
635[Put the complexity in the length docs. Fixes trac #3680
636Ian Lynagh <igloo@earth.li>**20100221191425]
637[nhc98 should build Data.Functor.
638Malcolm.Wallace@cs.york.ac.uk**20100221163218]
639[Update the exitWith docs
640Ian Lynagh <igloo@earth.li>**20100213140004
641 Error pointed out by Volker Wysk <vw@volker-wysk.de>
642]
643[Handle NaN, -Infinity and Infinity in the toRational for Float/Double (#3676)
644Simon Marlow <marlowsd@gmail.com>**20100211101955
645 Ignore-this: 261415363303efca265e80290eac5f28
646]
647[For nhc98, import unsafeInterleaveIO rather than defining it here.
648Malcolm.Wallace@cs.york.ac.uk**20100204171021]
649[Stifle warning about unused return value
650benl@cse.unsw.edu.au**20100203025537]
651[fix #3832: use the locale encoding in openTempFile
652Simon Marlow <marlowsd@gmail.com>**20100120211830
653 Ignore-this: df4f778cc5fefb32290c798db722632c
654 Also while I was here fix an XXX: the Handle contained an
655 uninformative string like <fd: 4> for error messages rather than the
656 real file path.
657]
658[Fix the build: export void, so it doesn't give an unused binding warning
659Ian Lynagh <igloo@earth.li>**20100116174451]
660[hIsEOF: don't do any decoding (#3808)
661Simon Marlow <marlowsd@gmail.com>**20100112230317
662 Ignore-this: 6a384dd2d547ffe3ad3762920e5c1671
663]
664[Control.Monad: +void :: f a -> f ()
665gwern0@gmail.com**20100108214455
666 Ignore-this: 4dc07452315f2d1b4941903ff42fc45f
667 See http://hackage.haskell.org/trac/ghc/ticket/3292
668 Turns m a -> m (). Lets one call functions for their side-effects without
669 having to get rid of their return values with '>> return ()'. Very useful
670 in many contexts (parsing, IO etc.); particularly good for 'forkIO' and 'forM_',
671 as they demand return types of 'IO ()' though most interesting IO functions
672 return non-().
673]
674[Replace the implementation of mergesort with a 2x faster one.
675Malcolm.Wallace@cs.york.ac.uk**20091224152014
676 See ticket http://hackage.haskell.org/trac/ghc/ticket/2143.
677]
678[Restore previous Data.Typeable.typeOf*Default implementations for non-ghc.
679Malcolm.Wallace@cs.york.ac.uk**20091223142625
680 Not all compilers have ScopedTypeVariables.
681]
682[Add comments about double bounds-checking, and fast paths for rectangular arrays
683simonpj@microsoft.com**20091218165655
684 Ignore-this: ea0849419dc00927aba4bd410b1cc58d
685 
686 See Note [Double bounds-checking of index values] for the details.
687 
688 The fast paths omit the doubled checks for cases we know about
689]
690[Fix Trac #3245: memoising typeOf
691simonpj@microsoft.com**20091218155117
692 Ignore-this: 5a178a7f2222293c5ee0c3c43bd1b625
693 
694 The performance bug in #3245 was caused by computing the typeRep
695 once for each call of typeOf, rather than once for each dictionary
696 contruction.  (Computing TypeReps is reasonably expensive, because
697 of the hash-consing machinery.)
698 
699 This is readily fixed by putting the TypeRep construction outside
700 the lambda.  (Arguably GHC might have worked that out itself,
701 but it involves floating something between a type lambda and a
702 value lambda, which GHC doesn't currently do. If it happens a lot
703 we could fix that.)
704]
705[Mark 'index' as INLINE in GHC.Arr
706simonpj@microsoft.com**20091216170441
707 Ignore-this: a4df9d8acf496c8e0e9ce5a520509a2a
708 
709 This makes indexing much faster. See Trac #1216
710]
711[Comment the remaining orphan instance modules
712Ian Lynagh <igloo@earth.li>**20091206125021]
713[De-orphan Eq/Ord Float/Double
714Ian Lynagh <igloo@earth.li>**20091205181238]
715[Add comments to "OPTIONS_GHC -fno-warn-orphans" pragmas
716Ian Lynagh <igloo@earth.li>**20091205165854]
717[Data.Either.partitionEithers was insufficiently lazy.
718Malcolm.Wallace@cs.york.ac.uk**20091202032807
719 Ignore-this: 77e1b3288f66608c71458d8a91bcbe12
720 Spotted by Daniel Fischer.
721]
722[fix the docs regarding finalizer guarantees
723Simon Marlow <marlowsd@gmail.com>**20091130144409
724 Ignore-this: d1ab9532c74a002b8075ff60febcbe2d
725]
726[x86_64 requires more stack
727Malcolm.Wallace@cs.york.ac.uk**20091201033745]
728[check for size < 0 in mallocForeignPtrBytes and friends (#3514)
729Simon Marlow <marlowsd@gmail.com>**20091125143822
730 Ignore-this: 91077d01da2bbe1dfed5155e8b40da9
731]
732[hGetContents: close the handle properly on error
733Simon Marlow <marlowsd@gmail.com>**20091125123435
734 Ignore-this: bc37ff678acc6e547dc390285e056eb9
735 
736 When hGetContents caught an error it was closing the handle and then
737 throwing the exception, without updating the handle with the new
738 closed state.  This lead to a double-closed, which was the cause of
739 
740 *** glibc detected *** ./Setup: double free or corruption
741 
742 when iconv_close was called twice on the decoder.
743 
744 See http://hackage.haskell.org/trac/hackage/ticket/609
745]
746[Fix arities of mapFB and zipFB
747Roman Leshchinskiy <rl@cse.unsw.edu.au>**20091126232219
748 Ignore-this: c4e14cd0a92622549c86e67237a40865
749]
750[Remove an unnecessary -fno-warn-orphans flag
751Ian Lynagh <igloo@earth.li>**20091126123404]
752[Tweak layout to work with alternative layout rule
753Ian Lynagh <igloo@earth.li>**20091125232349]
754[Tweak layout to be accepted by the alternative layout rul
755Ian Lynagh <igloo@earth.li>**20091125194147]
756[Make sure zipWithFB has arity 2
757Roman Leshchinskiy <rl@cse.unsw.edu.au>**20091125010003
758 Ignore-this: 4cf60c55666f03d22a9f5a6e07f52d36
759 
760 It gets 2 arguments in the "zipWith" rule but its arity was higher and the new
761 inliner didn't inline it sometimes, for instance here:
762 
763 mpp ::  [Double] -> [Double] -> [Double] -> [Double] -> [Double]
764 mpp as bs cs ds = zipWith (*) (zipWith (+) as bs) (zipWith (+) cs ds)
765 
766 This was a regression vs. 6.10.
767]
768[Remove an old comment
769Ian Lynagh <igloo@earth.li>**20091124134647]
770[De-orphan the Eq/Ord Integer instances
771Ian Lynagh <igloo@earth.li>**20091124133639]
772[Whitespace only
773Ian Lynagh <igloo@earth.li>**20091124133421]
774[Derive some more instances, rather than writing them by hand
775Ian Lynagh <igloo@earth.li>**20091124011747]
776[We can now derive Ord ()
777Ian Lynagh <igloo@earth.li>**20091124011416]
778[De-orphan tuple Eq/Ord instances
779Ian Lynagh <igloo@earth.li>**20091123233343]
780[Control.Exception.Base no longer has any orphans
781Ian Lynagh <igloo@earth.li>**20091123224905]
782[De-orphan the MonadFix ST instance for GHC
783Ian Lynagh <igloo@earth.li>**20091123223544]
784[Rearrange the contents of Control.Monad.ST; no functionality changes
785Ian Lynagh <igloo@earth.li>**20091123222702]
786[De-orphan the Eq/Ord [a] instances
787Ian Lynagh <igloo@earth.li>**20091123215635]
788[De-orphan the Eq/Ord Char instances
789Ian Lynagh <igloo@earth.li>**20091123202253]
790[De-orphan the Eq/Ord Bool instances
791Ian Lynagh <igloo@earth.li>**20091123201817]
792[Move Eq/Ord Ordering instances to de-orphan them
793Ian Lynagh <igloo@earth.li>**20091123194310]
794[Remove ffi warnings for nhc98.
795Malcolm.Wallace@cs.york.ac.uk**20091123063743]
796[Second attempt to fix #1185 (forkProcess and -threaded)
797Simon Marlow <marlowsd@gmail.com>**20091111151915
798 Ignore-this: fa5f5d5e4e080d4b612a37244f937f9c
799 
800 Patch 2/2: first patch is to ghc
801 
802 This time without dynamic linker hacks, instead I've expanded the
803 existing rts/Globals.c to cache more CAFs, specifically those in
804 GHC.Conc.  We were already using this trick for signal handlers, I
805 should have realised before.
806 
807 It's still quite unsavoury, but we can do away with rts/Globals.c in
808 the future when we switch to a dynamically-linked GHCi.
809]
810[Rollback #1185 fix
811Simon Marlow <marlowsd@gmail.com>**20091106140629
812 Ignore-this: cd5667e8474e37e01ba26a1984274811
813 
814 rolling back:
815 
816 Tue Nov  3 16:05:40 GMT 2009  Simon Marlow <marlowsd@gmail.com>
817   * Fix #1185: restart the IO manager after fork()
818   
819   This is the libraries/base part of the patch; there is a corresponding
820   patch to GHC itself.
821   
822   The main change is that we now keep track of the IO manager's ThreadId
823   in a top-level MVar, and ensureIOManagerIsRunning checks whether a
824   previous IO manager thread is alive before starting one.  In the child
825   of fork(), we can hence call ensureIOManagerIsRunning to restart the
826   IO manager.
827 
828     M ./GHC/Conc.lhs -46 +44
829 
830 Wed Nov  4 17:49:45 GMT 2009  Ian Lynagh <igloo@earth.li>
831   * Fix the build on Windows
832 
833     M ./GHC/Conc.lhs -6 +4
834]
835[Fix the build on Windows
836Ian Lynagh <igloo@earth.li>**20091104174945]
837[Fix #1185: restart the IO manager after fork()
838Simon Marlow <marlowsd@gmail.com>**20091103160540
839 Ignore-this: 6dc05464f1500104554637f4759738cc
840 
841 This is the libraries/base part of the patch; there is a corresponding
842 patch to GHC itself.
843 
844 The main change is that we now keep track of the IO manager's ThreadId
845 in a top-level MVar, and ensureIOManagerIsRunning checks whether a
846 previous IO manager thread is alive before starting one.  In the child
847 of fork(), we can hence call ensureIOManagerIsRunning to restart the
848 IO manager.
849]
850[improve the documentation for throwErrnoIfRetry
851Simon Marlow <marlowsd@gmail.com>**20091016112404
852 Ignore-this: b77275cacf730e15757946027168f63e
853]
854[Don't inline unpackFoldrCString ever
855simonpj@microsoft.com**20091029135350
856 Ignore-this: 85d672649b1b776efc7e97500b05d4f9
857]
858[Inline more default methods
859simonpj@microsoft.com**20091029135330
860 Ignore-this: 289c44b0afd6d5631c2a4e0664275ca9
861 
862 Namely Monad: (>>)
863        Eq:    (==), (/=)
864        Num:   (-), negate
865        Real:  quot, rem, div, mod, recip, (/), truncate
866        Float: (**), logBase, sqrt, tan, tanh
867]
868[Move error messages out of INLINEd default methods
869simonpj@microsoft.com**20091029135118
870 Ignore-this: 9e35dc947f94827a3529eb53a41575fd
871 
872 No need to duplicate the error generation!
873]
874[Exploit now-working default-method INLINE pragmas for Data.Bits
875simonpj@microsoft.com**20091029135041
876 Ignore-this: 8adf225f31ca7a3181ee087e9e4fe535
877 
878 * Add INLINE pragmas to default methods for class Bits
879 
880 * Remove redundant instance methods elsewhere, now that
881   the default method will do the job
882]
883[Tidy up and comment imports
884simonpj@microsoft.com**20091029134414
885 Ignore-this: bf2be31035de975d8995e988933cc940
886]
887[Inline foldr and (.) when applied to two arguments not three
888simonpj@microsoft.com**20091029134335
889 Ignore-this: fccb6f3e90e15f44cb465814be85ede2
890 
891 The new INLINE story is (by design) arity-sensitive, so we must
892 put fewer argument on the LHS for foldr and (.)
893]
894[dirUtils.c no longer available
895Malcolm.Wallace@cs.york.ac.uk**20091013093833]
896[Make hGetContents throw an exception if an error is encountered
897Simon Marlow <marlowsd@gmail.com>**20091012152955
898 Ignore-this: 9f7a7176193eab25c9daaacd9261f2de
899 
900 Strictly speaking this breaks Haskell 98 compatibility, which requires
901 hGetContents to just end the lazy stream silently if an error is
902 encountered.  However, for a few reasons we think it will make
903 everyone's life a bit easier if we make this change
904 
905  1. Errors will be a lot more common in GHC 6.12.1, in the form
906     of Unicode decoding errors.
907 
908  2. When Haskell 98 was designed, we didn't know how to throw
909     exceptions from inside lazy I/O, but now we do.
910 
911  3. If anyone is actually relying on the previous behaviour, their
912     code is arguably broken.
913]
914[Re-instate System.Console.Getopt for nhc98 builds.
915Malcolm.Wallace@cs.york.ac.uk**20091013092843
916 Although it was split out of base a while back, that change was
917 reverted for ghc soon afterwards, but nhc98 never noticed.
918]
919[Roll back "Another instance of nhc98's strange import semantics."
920Ian Lynagh <igloo@earth.li>**20091009185618
921 Fri Oct  9 14:50:51 BST 2009  Malcolm.Wallace@cs.york.ac.uk
922 GHC (correctly) warns about the unused import, which breaks the validate
923 build.
924]
925[Roll back "Cope with nhc98's (occasionally-strange) import semantics"
926Ian Lynagh <igloo@earth.li>**20091009184704
927 Fri Oct  9 14:43:51 BST 2009  Malcolm.Wallace@cs.york.ac.uk
928 GHC (correctly) warns about the unused import, which breaks the validate
929 build.
930]
931[It seems that nhc98 needs defaulting in Data.Fixed.
932Malcolm.Wallace@cs.york.ac.uk**20091009135242]
933[Another instance of nhc98's strange import semantics.
934Malcolm.Wallace@cs.york.ac.uk**20091009135051]
935[Make Data.Functor compatible with non-GHC compilers.
936Malcolm.Wallace@cs.york.ac.uk**20091009134821]
937[Cope with nhc98's (occasionally-strange) import semantics.
938Malcolm.Wallace@cs.york.ac.uk**20091009134351]
939[Fix gratuitous breakage of nhc98 in System.IO.
940Malcolm.Wallace@cs.york.ac.uk**20091009134001]
941[Fix gratuitous breakage of nhc98 in Control.Exception.Base.
942Malcolm.Wallace@cs.york.ac.uk**20091009133615]
943[Fix gratuitous breakage of non-GHC in Data.Fixed.
944Malcolm.Wallace@cs.york.ac.uk**20091009133330]
945[Fix gratuitous breakage for non-GHC in Data.Bits.
946Malcolm.Wallace@cs.york.ac.uk**20091009133257]
947[Use UTF-32LE instead of UTF32LE
948Simon Marlow <marlowsd@gmail.com>**20091006100207
949 Ignore-this: 7f881e36543d250ef848c9f60d67655a
950 The latter is not recognised by some iconv implementations.
951]
952[Strip any Byte Order Mark (BOM) from the front of decoded streams.
953Ben.Lippmeier@anu.edu.au*-20090930084229
954 Ignore-this: d0d0c3ae87b31d71ef1627c8e1786445
955 When decoding to UTF-32, Solaris iconv inserts a BOM at the front
956 of the stream, but Linux iconv doesn't.
957]
958[use UTF32BE/UTF32LE instead of UCS-4/UCS-4LE
959Simon Marlow <marlowsd@gmail.com>**20091005101554
960 Ignore-this: 2aef5e9bec421e714953b7aa1bdfc1b3
961]
962[Strip any Byte Order Mark (BOM) from the front of decoded streams.
963Ben.Lippmeier@anu.edu.au**20090930084229
964 Ignore-this: d0d0c3ae87b31d71ef1627c8e1786445
965 When decoding to UTF-32, Solaris iconv inserts a BOM at the front
966 of the stream, but Linux iconv doesn't.
967]
968[Add traceEvent :: String -> IO ()
969Simon Marlow <marlowsd@gmail.com>**20090925141257
970 Ignore-this: 8b1888bbf9682ffba13f815b6000e4b1
971 For emitting an event via the RTS tracing framework
972]
973[Fix the error message when flushing the read buffer of a non-seekable Handle
974Simon Marlow <marlowsd@gmail.com>**20090923090536
975 Ignore-this: 4342026df93759d99480f4e13f80a492
976]
977[Fix #3534: No need to flush the byte buffer when setting binary mode
978Simon Marlow <marlowsd@gmail.com>**20090923090445
979 Ignore-this: 625817ed7ae2c12291eb993a99dc640a
980]
981[Use let !y = x in .. x .. instead of seq in $! and evaluate (#2273)
982Simon Marlow <marlowsd@gmail.com>**20090916140454]
983[make some Applicative functions into methods, and split off Data.Functor (proposal #3335)
984Ross Paterson <ross@soi.city.ac.uk>**20090915173109
985 Ignore-this: a0cff4de6dfdbcbd56a66101bc4855a9
986 
987 The following functions
988 
989     (<$) :: Functor f => a -> f b -> f a
990     (*>) :: Applicative f => f a -> f b -> f b
991     (<*) :: Applicative f => f a -> f b -> f a
992     some :: Alternative f => f a -> f [a]
993     many :: Alternative f => f a -> f [a]
994 
995 are moved into the corresponding classes, with the existing implementations
996 as default definitions.  This gives people creating instances the option of
997 defining specialized implementations of these functions, though they should
998 be equivalent to the default definitions.
999 
1000 Although (<$) is now a method of the Functor class, it is hidden in the
1001 re-export by the Prelude, Control.Monad and Monad.  The new module
1002 Data.Functor exposes the full class, plus the function (<$>).  These are
1003 also re-exported by Control.Applicative.
1004]
1005[On Windows, use the console code page for text file encoding/decoding.
1006Judah Jacobson <judah.jacobson@gmail.com>**20090913022126
1007 Ignore-this: 86c2f2db8ef92b751599795d3195187b
1008 
1009 We keep all of the code page tables in the module
1010 GHC.IO.Encoding.CodePage.Table.  That file was generated automatically
1011 by running codepages/MakeTable.hs; more details are in the comments at the
1012 start of that script.
1013 
1014 Storing the lookup tables adds about 40KB to each statically linked executable;
1015 this only increases the size of a "hello world" program by about 7%.
1016 
1017 Currently we do not support double-byte encodings (Chinese/Japanese/Korean), since
1018 including those codepages would increase the table size to 400KB.  It will be
1019 straightforward to implement them once the work on library DLLs is finished.
1020]
1021[Fix "init" docs: the input list need not be finite. Fixes trac #3465
1022Ian Lynagh <igloo@earth.li>**20090911210437]
1023[Bump base version to 4.2.0.0
1024Ian Lynagh <igloo@earth.li>**20090911153913]
1025[Address #3310
1026Simon Marlow <marlowsd@gmail.com>**20090830152850
1027 Ignore-this: 40c7f7c171ee299a83092fd360a952b7
1028 
1029  - Rename BlockedOnDeadMVar   -> BlockedIndefinitelyOnMVar
1030  - Rename BlockedIndefinitely -> BlockedIndefinitelyOnSTM
1031  - instance Show BlockedIndefinitelyOnMVar is now
1032      "blocked indefinitely in an MVar operation"
1033  - instance Show BlockedIndefinitelyOnSTM is now
1034      "blocked indefinitely in an STM transaction"
1035 
1036 clients using Control.OldException will be unaffected (the new
1037 exceptions are mapped to the old names).  However, for base4-compat
1038 we'll need to make a version of catch/try that does a similar
1039 mapping.
1040]
1041[Fix unicode conversion for MSB architectures
1042Ben.Lippmeier@anu.edu.au**20090830130028
1043 This fixes the SPARC/Solaris build.
1044]
1045[Fix #3441: detect errors in partial sequences
1046Simon Marlow <marlowsd@gmail.com>**20090830075909
1047 Ignore-this: d12a75d95e0cae5eb1555266810ec281
1048]
1049[Fix hWaitForInput
1050Simon Marlow <marlowsd@gmail.com>**20090827152116
1051 Ignore-this: 2550e911f1a4d4357a5aa8d1764238ce
1052 It was erroneously waiting when there were bytes to decode waiting in
1053 the byte buffer.
1054]
1055[fix debugging code
1056Simon Marlow <marlowsd@gmail.com>**20090827150628
1057 Ignore-this: e1c82fdc19a22e247cd69ff6fa11921d
1058]
1059[Allow for configurable iconv include and library locations.
1060Matthias Kilian <kili@outback.escape.de>**20090826154406
1061 Ignore-this: be95fab611a5534cf184b508964ed498
1062 This should help to fix the build on OpenBSD.
1063]
1064[typo in comment
1065Simon Marlow <marlowsd@gmail.com>**20090826085252
1066 Ignore-this: 1903ee0f354157a6ed3871c100f6b1b9
1067]
1068[un-hide some modules from the Haddock docs
1069Simon Marlow <marlowsd@gmail.com>**20090825152457
1070 Ignore-this: dce6606f93cf977fb24ebe99082dfa62
1071]
1072[Apply fix for #1548, from squadette@gmail.com
1073Simon Marlow <marlowsd@gmail.com>**20090819120700
1074 Ignore-this: 31c237c46a6445f588ed4b8c51bb6231
1075]
1076[improvements to Data.Fixed: instances for Typeable and Data, more predefined types
1077Ashley Yakeley <ashley@semantic.org>**20090812055058
1078 Ignore-this: feeece36d5632f02a05d137d2a39ab78
1079]
1080[Fix "Cabal check" warnings
1081Ian Lynagh <igloo@earth.li>**20090811215856]
1082[Add a GHC.Constants module; fixes trac #3094
1083Ian Lynagh <igloo@earth.li>**20090809183252]
1084[Apply proposal #3393
1085Ian Lynagh <igloo@earth.li>**20090809134717
1086 Add openTempFileWithDefaultPermissions and
1087 openBinaryTempFileWithDefaultPermissions.
1088]
1089[Add some more C wrappers; patch from Krister Walfridsson
1090Ian Lynagh <igloo@earth.li>**20090807200631
1091 Fixes 21 testsuite errors on NetBSD 5.99.
1092]
1093[Fixing configure for autoconf 2.64
1094Alexander Dunlap <alexander.dunlap@gmail.com>**20090805060748
1095 Ignore-this: 992ab91ae3d68c12dbb265776e33e243
1096]
1097[add INLINE toList
1098Ross Paterson <ross@soi.city.ac.uk>**20090806142853
1099 Ignore-this: aba16aabb17d5dca44f15d188945680e
1100 
1101 In anticipation of the fixing of #2353.
1102]
1103[fix a copyright
1104Simon Marlow <marlowsd@gmail.com>**20090805134045
1105 Ignore-this: b0ffbdd38fbba121e8bcba37c4082a60
1106]
1107[Tweak the BufferedIO class to enable a memory-mapped file implementation
1108Simon Marlow <marlowsd@gmail.com>**20090805134036
1109 Ignore-this: ec67d7a0a6d977438deaa342503f77e0
1110 We have to eliminate the assumption that an empty write buffer can be
1111 constructed by setting the buffer pointers to zero: this isn't
1112 necessarily the case when the buffer corresponds to a memory-mapped
1113 file, or other in-memory device implementation.
1114]
1115[Deprecate Control.OldException
1116Ian Lynagh <igloo@earth.li>**20090804143910]
1117[Windows build fix, following RTS tidyup
1118Simon Marlow <marlowsd@gmail.com>**20090803131121
1119 Ignore-this: ce862fb91c2b234211a8757f98690778
1120]
1121[Updates to follow the RTS tidyup
1122Simon Marlow <marlowsd@gmail.com>**20090801220743
1123 Ignore-this: 6e92412df93a66c12d75344053d5634
1124 C functions like isDoubleNaN moved here (primFloat.c)
1125]
1126[Add integer-simple as a build option
1127Ian Lynagh <igloo@earth.li>**20090722013151]
1128[Use shift[LR]Integer in the Bits Integer instance
1129Ian Lynagh <igloo@earth.li>**20090721222440]
1130[depend directly on integer-gmp, rather than indirecting through integer
1131Ian Lynagh <igloo@earth.li>**20090721185228]
1132[Move the instances of Functor and Monad IO to GHC.Base, to avoid orphans
1133Simon Marlow <marlowsd@gmail.com>**20090722102130
1134 Ignore-this: a7d85ac0025d559674249de0108dbcf4
1135]
1136[move "instance Exception Dynamic" so it isn't an orphan
1137Simon Marlow <marlowsd@gmail.com>**20090721093854
1138 Ignore-this: 5ede91ecfec2112c91b699d4de87cd02
1139]
1140[Improve the index checking for array accesses; fixes #2120 #2669
1141Ian Lynagh <igloo@earth.li>**20090719153228
1142 As well as checking that offset we are reading is actually inside the
1143 array, we now also check that it is "in range" as defined by the Ix
1144 instance. This fixes confusing behaviour (#2120) and improves some error
1145 messages (#2669).
1146]
1147[Make chr say what its argument was, if it's a bad argument
1148Ian Lynagh <igloo@earth.li>**20090718151049]
1149[remove unused warning
1150Simon Marlow <marlowsd@gmail.com>**20090715124416
1151 Ignore-this: 31f613654089d0f4a44363946087b41e
1152]
1153[warning fix: -fno-implicit-prelude -> -XNoImplicitPrelude
1154Simon Marlow <marlowsd@gmail.com>**20090715122839
1155 Ignore-this: dc8957249731d5bcb71c01899e5adf2b
1156]
1157[Add hGetEncoding :: Handle -> IO (Maybe TextEncoding)
1158Simon Marlow <marlowsd@gmail.com>**20090715122519
1159 Ignore-this: 14c3eff996db062da1199739781e4708
1160 as suggested during the discussion on the libraries list
1161]
1162[Add more documentation to mkTextEncoding
1163Simon Marlow <marlowsd@gmail.com>**20090715122414
1164 Ignore-this: 97253b2624267df3a246a18121e8ea81
1165 noting that "//IGNORE" and "//TRANSLIT" suffixes can be used with GNU
1166 iconv.
1167]
1168[Add the utf8_bom codec
1169Simon Marlow <marlowsd@gmail.com>**20090715122257
1170 Ignore-this: 1c9396cd805201fe873a39382ced79c7
1171 as suggested during the discussion on the libraries list.
1172]
1173[Export Unicode and newline functionality from System.IO; update Haddock docs
1174Simon Marlow <marlowsd@gmail.com>**20090713113104
1175 Ignore-this: c3f017a555335aa55d106253393f72e2
1176]
1177[add a comment about the non-workingness of CHARBUF_UTF16
1178Simon Marlow <marlowsd@gmail.com>**20090707124406
1179 Ignore-this: 98d00411b68d688b3b4cffc9507b1f35
1180]
1181[Fix build on Windows
1182Ian Lynagh <igloo@earth.li>**20090711004351]
1183[Fix some "warn-unused-do-bind" warnings where we want to ignore the value
1184Ian Lynagh <igloo@earth.li>**20090710204513]
1185[Use throwErrnoIfMinus1_ when calling getrusage
1186Ian Lynagh <igloo@earth.li>**20090710204221]
1187[Remove an unused import
1188Ian Lynagh <igloo@earth.li>**20090710153345]
1189[reportStackOverflow now returns IO ()
1190Ian Lynagh <igloo@earth.li>**20090710153257
1191 It used to do "return undefined" to return IO a.
1192]
1193[GHC.Conc.reportError now returns IO ()
1194Ian Lynagh <igloo@earth.li>**20090710152646
1195 It used to return IO a, by "return undefined".
1196]
1197[Fix some "warn-unused-do-bind" warnings where we want to ignore the value
1198Ian Lynagh <igloo@earth.li>**20090710152526]
1199[Minor SampleVar refactoring
1200Ian Lynagh <igloo@earth.li>**20090710151438]
1201[Fix "warn-unused-do-bind" warnings in GHC/IO/Handle/Text.hs
1202Ian Lynagh <igloo@earth.li>**20090710122905]
1203[Fix some "warn-unused-do-bind" warnings where we just want to ignore the result
1204Ian Lynagh <igloo@earth.li>**20090710005638]
1205[Use the result of writeCharBuf in GHC/IO/Encoding/Latin1.hs too
1206Ian Lynagh <igloo@earth.li>**20090710004032]
1207[Minor code tidyups in GHC.Conc
1208Ian Lynagh <igloo@earth.li>**20090710003801]
1209[Fix "warn-unused-do-bind" warning in GHC.Conc
1210Ian Lynagh <igloo@earth.li>**20090710003530
1211 If we fail to communicate with the IO manager then we print a warning
1212 using debugErrLn from the ghc-prim package.
1213]
1214[Fix "warn-unused-do-bind" warnings in System.Posix.Internals
1215Ian Lynagh <igloo@earth.li>**20090709164546]
1216[Fix "warn-unused-do-bind" warnings where we really do want to ignore the result
1217Ian Lynagh <igloo@earth.li>**20090709163912]
1218[Add back imports needed on Windows
1219Ian Lynagh <igloo@earth.li>**20090707181924]
1220[Remove unused imports
1221Ian Lynagh <igloo@earth.li>**20090707115810]
1222[Remove unused imports from base
1223simonpj@microsoft.com**20090706111842
1224 Ignore-this: f9b5f353e3bb820f787c56d615b28765
1225 
1226 These unused imports are detected by the new unused-import code
1227 
1228]
1229[Use the result of writeCharBuf
1230Simon Marlow <marlowsd@gmail.com>**20090706133303
1231 Ignore-this: 52288dd559bf4c4f313df6197091d935
1232   
1233 This only makes a difference when CHARBUF_UTF16 is in use, which it
1234 normally isn't.  I suspect CHARBUF_UTF16 doesn't currently work for
1235 other reasons (CHARBUF_UTF16 was an experiment before I wrote the
1236 GHC.IO.Encoding.UTF* codecs), but this patch at least makes it
1237 slightly closer to working.
1238]
1239[Remove some cruft from Data.HashTable
1240Ian Lynagh <igloo@earth.li>**20090706181630]
1241[Add 'eof' to Text.ParserCombinators.ReadP
1242simonpj@microsoft.com**20090706111801
1243 Ignore-this: 2aea7b848e00c894761bc4011adaa95d
1244 
1245 Add a ReadP parser that succeeds at the end of input. Very useful!
1246 
1247]
1248[Don't export CLDouble for GHC; fixes trac #2793
1249Ian Lynagh <igloo@earth.li>**20090705155120
1250 We never really supported CLDouble (it was a plain old double underneath),
1251 and pretending that we do does more harm than good.
1252]
1253[a byte between 0x80 and 0xBF is illegal immediately (#3341)
1254Simon Marlow <marlowsd@gmail.com>**20090702081415
1255 Ignore-this: dc19ef59a1a21118d5a7dd38aa2f611c
1256]
1257[avoid a warning
1258Simon Marlow <marlowsd@gmail.com>**20090630084134
1259 Ignore-this: c92a45ee216faf01327feae9fe06d6e2
1260]
1261[Add a wrapper for libiconv.
1262Matthias Kilian <kili@outback.escape.de>**20090629183634
1263 Ignore-this: 23c6047c0d71b745b495cc223574a47f
1264]
1265[#include <sys/times.h> if we have it (should fix build problems)
1266Simon Marlow <marlowsd@gmail.com>**20090629085351
1267 Ignore-this: a35e93b37ca9595c73460243180f4b9d
1268]
1269[set binary mode for existing FDs on Windows (fixes some GHCi test failures)
1270Simon Marlow <marlowsd@gmail.com>**20090626120522
1271 Ignore-this: 580cf636e9c77d8427aff6861d089481
1272]
1273[Move directory-related stuff to the unix package
1274Simon Marlow <marlowsd@gmail.com>**20090625120325
1275 Ignore-this: b997b3cbce0a46ca87ad825bbdc0a411
1276 now that it isn't used on Windows any more.
1277]
1278[TAG 2009-06-25
1279Ian Lynagh <igloo@earth.li>**20090625160056]
1280Patch bundle hash:
1281b87fd3bc12acd6267ac9bf745b5b064cdb64f790