Rewrite FPTOOLS_CHECK_HTYPE to be cross-compilation-friendly
Inspired by a patch from Mark Lentczner

No need to include the OpenGL / OpenAL headers in aclocal.m4

Export the affinity API from Control.Concurrent: forkOn and friends.

forkOn             :: Int -> IO () -> IO ThreadId
forkOnWithUnmask   :: Int -> ((forall a . IO a -> IO a) -> IO ()) -> IO ThreadId
getNumCapabilities :: IO Int
threadCapability   :: ThreadId -> IO (Int, Bool)

Following discussion on the libraries list, I renamed forkOnIO to
forkOn.  In due course we might want to also rename forkIO to fork.

I left the Int argument as it is, it's quite useful to be able to
specify a number to be interpreted modulo the actual number of
processors.

I also used the term "capability" consistently.  It might not be the
best choice, but we have to pick something.

Deprecate Control.Exception.blocked in favour of getMaskingState

fix Haddock error

add forkIOWithUnmask, forkOnIOWithUnmask; deprecate forkIOUnmasked

With forkIOUnmasked it wasn't possible to reliably set up an exception
handler in the child thread, because exceptions were immediately
unmasked.

forkIOWithUnmask   ::        ((forall a . IO a -> IO a) -> IO ()) -> IO ThreadId
forkOnIOWithUnmask :: Int -> ((forall a . IO a -> IO a) -> IO ()) -> IO ThreadId

Add GHC.IO.Handle.FD.openFileBlocking (#4248)
like openFile, but opens the file without O_NONBLOCK

Add allowInterrupt :: IO ()  (#4810)

docs:

-- | When invoked inside 'mask', this function allows a blocked
-- asynchronous exception to be raised, if one exists.  It is
-- equivalent to performing an interruptible operation (see
-- #interruptible#), but does not involve any actual blocking.
--
-- When called outside 'mask', or inside 'uninterruptibleMask', this
-- function has no effect.

Fix documentation for mkWeakIORef: argument is finalizer, not key or value

Work around a limitation in the hsc2hs cross-compilation mode

Rename System.Event to GHC.Event
It's just an internal GHC library, for now at least

Never use epoll_create1; fixes trac #5005
There is little benefit to using epoll_create1 (especially if we still
have the epoll_create code too), and it cuases problems if people build
a GHC binary on one machine and try to use it on another.

Fix warning

FIX #2271
Faster rounding functions for Double and float with Int or Integer results.
Fixes #2271.
Since some glibc's have buggy rintf or rint functions and the behaviour of
these functions depends on the setting of the rounding mode, we provide our
own implementations which always round ties to even.

Also added rewrite rules and removed trailing whitespace.

add threadCapability :: ThreadId -> IO (Int,Bool)

-- | returns the number of the capability on which the thread is currently
-- running, and a boolean indicating whether the thread is locked to
-- that capability or not.  A thread is locked to a capability if it
-- was created with @forkOnIO@.

follow changes to threadStatus#, and update stat values

Make the Timeout exception a newtype instead of a datatype

improve discussion of the laws (doc comments only)

following a suggestion of Russell O'Connor on the libraries list.

Add some more explanation to the skip channel example in the MVar docs

Grammar fix

Expand and clarify MVar documentation.

Remove most of GHC.PArr
- First step of migrating this code into the dph package

Roll back generics changes in the HEAD repos

Do not export GHC.Generics from GHC.Base

Fix incorrect #ifdef for nhc98

Add Data.String to the nhc98 build

Regenerated cbits/WCsubst.c based on Unicode 6.0.0

Deprecate System.IO.Error.{catch,try} and Prelude.catch; fixes trac #4865

add getNumCapabilities :: IO Int

If we ever get around to implementing #3729 and #3210, then the number
of capabilities will vary at runtime, so we need to move
numCapabilities into the IO monad.

add missing extensions for Windows

add NoImplicitPrelude (fix Windows build failure)

Use explicit language extensions & remove extension fields from base.cabal

Add explicit {-# LANGUAGE xxx #-} pragmas to each module, that say
what extensions that module uses.  This makes it clearer where
different extensions are used in the (large, variagated) base package.

Now base.cabal doesn't need any extensions field

Thanks to Bas van Dijk for doing all the work.

fix silly mistake in hGetBufSome (#4895)

Clean up remnants of the Event Manager after forkProcess. Closes #4449

Document System.Event

Add NondecreasingIndentation to the extensions needed

Remove extensions required for GHC < 6.10

Added a Typeable instance for SampleVar

Derived Eq instance for QSem and QSemN

Derived Eq instance for Chan

fix #4876

Instances for ST not available in nhc98.

indentation tweaks (whitespace only)

indentation tweaks, re-order exports

Add Applicative instances for ST monads (proposal #4455)

patch from Bas van Dijk

Always use 8k buffers instead of BUFSIZ
This makes a huge difference to I/O performance for me on Windows,
where BUFSIZ is 512.  It might help on Mac too.

Replace uses of the old catch function with the new one

Fix build on Windows

Fix warnings

Use onException for exception cleanup, and mask async exceptions

Drop closeFd from Control.Concurrent, rename to closeFdWith

Fix #4533 - unregister callbacks on exception, fixing a memory leak

Our problem here was that if a thread blocked in threadWait or
threadDelay and was killed by an exception thrown from another thread,
its registration with the IO manager would not be cleared.

The fix is simply to install exception handlers that do the cleanup and
propagate the exception.

Drop System.Mem.Weak's dependency on Prelude

Fix #4514 - IO manager deadlock

* The public APIs for threadWaitRead and threadWaitWrite remain unchanged,
  and now throw an IOError if a file descriptor is closed behind their
  backs.  This behaviour is documented.

* The GHC.Conc API is extended to add a closeFd function, the behaviour
  of which is documented.

* Behind the scenes, we add a new evtClose event, which is used only when
  one thread closes a file descriptor that other threads are blocking on.

* Both base's IO code and network use the new closeFd function.

Bump the version of base

Cache for powers of 10
Add a cache for commonly needed powers of 10 to speed up floatToDigits.

Fix typo in floatToDigits
The mDn value for powers of 2 >= floatDigits x - 1 was typo'ed, leading to longer than necessary show results in a few cases (e.g. 2.0^852).
Corrected in accordance with Burger and Dybvig's paper.

Performance enchancement for floatToDigits
Use quot and quotRem instead of div and divMod for dividing positive Integers since that is a bit faster.

FIX #4383
Use a better approximation to logBase 10 2 to prevent leading zeros in floatToDigits.

Add a Read instance for Data.Fixed.Fixed

Also export lines, words, unlines and unwords from Data.String

Do not export String from Data.Char

Export String from Data.String

extend the documentation about interruptible operations

fix a discarded exception in hClose

-XPArr is now -XParallelArrays

check for ClosedHandle in read/write operations on DuplexHandles (#4808)

Fix typo

fix hTell behaviour with Unicode Handles

Encode immediately in hPutStr and hPutChar
This means that decoding errors will be detected accurately, and can
be caught and handled.  Overall the implementation is simpler this way
too.

It does impose a performance hit on small hPutStrs, although larger
hPutStrs seem to be unaffected.  To compensate somewhat, I optimised
hPutStrLn.

Don't throw an error if the output buffer had no room
This is consistent with the other codecs, and will be relied on by
some upcoming changes in the IO library.

use LANGUAGE instead of OPTIONS_GHC

doc fix: don't refer to unblock.

Remove unused import on Windows

Remove an unnecessary fromIntegral

Remove a redundant fromIntegral

Make (^) and (^^) INLINABLE

This makes them perform well robustly
(e.g. in test perf/should_run/MethSharing)
rather than relying on a rather delicate
let-floating.  See Note [Inlining (^) in Real.lhs

TAG 2010-11-18

Remove redundant fromIntegral

Fixing uses of fromIntegral for Windows

Catch exceptions in current thread and throw them to the forked thread in runInUnboundThread

There's no need to explicitly check for blocked status in runInUnboundThread when we have mask

Use throwIO instead of throw in runInBoundThread and runInUnboundThread

Remove unnecessary fromIntegral calls

Add some comments to the generated Table.hs

System.Event.KQueue conditionally uses BangPatterns

Add LANGUAGE BangPatterns to modules that use bang patterns

Reimplement firstPowerOf2

Remove redundant import

Re-gen GHC/IO/Encoding/CodePage/Table.hs

Add a Makefile for MakeTable, and remove GHC.Num generated import

Fix whitespace in codepages/MakeTable.hs

Add an INLINE pragma on fromInteger on Int

Add an INLINE pragme for fmapDefault

hGetBuf: fix a case of a short read being returned (#4427)

Refer to 'mask' instead of 'block' in documentation of Control.Exception

Add showMultiLineString to GHC.Show

This is part of the fix for #4436

  showMultiLineString :: String -> [String]
  -- | Like 'showLitString' (expand escape characters using Haskell
  -- escape conventions), but
  --   * break the string into multiple lines
  --   * wrap the entire thing in double quotes
  -- Example:  @breakMultiLineString "hello\ngoodbye\nblah"@
  -- returns   @["\"hello\\", "\\goodbye\\", "\\blah\"" ]@
  -- where those "\\" are really just a single backslash
  -- (but I'm writing them here as Haskell literals)

CIntPtr, CUIntPtr, CIntMax, CUIntMax are new to nhc98.

Follow GHC.Bool/GHC.Types merge

Remove redundant imports, now that NoImplicitPrelude does not imply RebindableSyntax