Adjust behaviour of gcd

Change behaviour of 'gcd 0 0' from raising an exception to
returning 0 to make it total and conform to mathematical practice.

configure: fail if suseconds_t doesn't exist, except on Windows

On Windows we use Int32.

In configure, set $WINDOWS to YES or NO

rather than inlining the implementation of the test.

Refactor the FPTOOLS_CHECK_HTYPE macro

We can now specify what happens if the type doesn't exist

In configure, remove default Haskell equivalent of C types

The macro was just ignoring the defaults.

Remove wint_t configure test

We didn't actually use the result, and my Linux box doesn't have
wint_t.

Use CSUSeconds in getCPUTime and getCurrentTime. Fixes #4247.

The tv_usec field of struct timeval was incorrectly used as C type time_t; the actual C type is suseconds_t. On OS X, time_t is longer than suseconds_t, which caused garbage bits to be copied as reported in trace #4247 and #4970. This is patch 3 of 4 to fix those tickets.

Whitespace only. This patch is part 2 of 4 for trac #4247 and #4970.

Add Haskell types for C types useconds_t and suseconds_t, which are respectively CUSeconds and CSUSeconds.

The tv_usec field of struct timeval was incorrectly used as C type time_t; the actual C type is suseconds_t. On OS X, time_t is longer than suseconds_t, which caused garbage bits to be copied as reported in trac #4247 and #4970. This patch is part 1 of 4 to fix those tickets.

Make 'forever' inlinable (fixes Trac #5205)

See Note [Make forever INLINABLE] in Control.Monad

add GArrowSTKCL for flattening of fixpoints

Arrow.hs: fix loopl/loopr transposition

add GArrowKappa

fix type mistake in CodeTypes.hs

enable argument types in pga_{un}flatten

add GArrowTensor, GArrowUnit, and GArrowExponent which use type families to reduce the type-level clutter caused by generalized arrows having 3-4 parameters

add hetmet_unflatten

add support for hetmet_flatten casting variable

update GHC.HetMet.CodeTypes using *->*->* as the kind of environment classifiers

Private.hs: make datacon name different from tycon name, add explicit foralls

add experimental GArrowKappa

add first draft of GHC.HetMet.Private

add experimental GArrowStatic

rephrase GArrow{Sum,Prod} to make instance inference easier

add more fundeps for GArrow clases, remove -XFlexibleInstances

add GArrowSTKC, GArrowPCF

add ga_inl, ga_inr

re-order type arguments to GArrowProd

add Arrow=>GArrowProd instance

add ArrowChoice=>GArrowSum instance

fix incorrect type on GArrowCurry

final revision to GArrow classes

adjust some of the names in GHC.HetMet.GArrow

move the (Arrow a)=>(GArrow a (,)) instance to a separate file

remove unnecessary testing definition from CodeTypes.hs

make Control.Category a superclass of GArrow

add Control.Category instance for GArrow

add GArrow instance for Control.Arrow

improve comments in GHC.HetMet.GArrow

migrate HetMet base changes to git repo

Merge remote branch 'origin/master' into ghc-generics

Merge branch 'ghc-generics' of darcs.haskell.org/packages/base into ghc-generics

Remove datatype contexts from base

The Haskell' committee decided to remove datatype contexts from the language:
http://www.haskell.org/pipermail/haskell-prime/2011-January/003335.html

add final newline

document the behaviour of throwTo to the current thread (#4888)

document the memory model of IORef

docs: note strict sequential ordering of MVar operations

Add System.IO.char8, the encoding used by openBinaryFile,
and correct the documentation for hSetBinaryMode which claimed that
it was using the latin1 encoding when in fact it was using an
unchecked modulo-256 version of it.

Move tests from testsuite/tests/libraries

Add tests from testsuite/tests/h98

Merge branch 'master' of darcs.haskell.org/packages/base into ghc-generics

Merge remote branch 'origin/master' into ghc-generics

Change to the 0xEF80..0xEFFF private-use range for //ROUNDTRIP

Use Unicode private-use characters for roundtripping

This replaces the previous scheme (which used lone surrogates). The reason is that
there is Haskell software in the wild (i.e. the text package) that chokes on Char values
that do not represent Unicode characters.

This new approach will not work correctly if the reserved private-use characters are
actually encountered in the input, but we expect this to be rare.

Merge branch 'master' of darcs.haskell.org/packages/base into ghc-generics

Big patch to improve Unicode support in GHC. Validated on OS X and Windows, this
patch series fixes #5061, #1414, #3309, #3308, #3307, #4006 and #4855.

The major changes are:

 1) Make Foreign.C.String.*CString use the locale encoding

    This change follows the FFI specification in Haskell 98, which
    has never actually been implemented before.

    The functions exported from Foreign.C.String are partially-applied
    versions of those from GHC.Foreign, which allows the user to supply
    their own TextEncoding.

    We also introduce foreignEncoding as the name of the text encoding
    that follows the FFI appendix in that it transliterates encoding
    errors.

 2) I also changed the code so that mkTextEncoding always tries the
    native-Haskell decoders in preference to those from iconv, even on
    non-Windows. The motivation here is simply that it is better for
    compatibility if we do this, and those are the ones you get for
    the utf* and latin1* predefined TextEncodings anyway.

 3) Implement surrogate-byte error handling mode for TextEncoding

    This implements PEP383-like behaviour so that we are able to
    roundtrip byte strings through Strings without loss of information.

    The withFilePath function now uses this encoding to get to/from CStrings,
    so any code that uses that will get the right PEP383 behaviour automatically.

 4) Implement three other coding failure modes: ignore, throw error, transliterate

    These mimic the behaviour of the GNU Iconv extensions.

Merge branch 'master' of darcs.haskell.org/packages/base into ghc-generics

disable incorrect RULEs for Floats (#5178)

Adapt to the renaming of `Representable0` to `Generic`.

Merge branch 'master' of darcs.haskell.org/packages/base into ghc-generics

Merge branch 'monad-comp'

Add Representable0 instances to Either and Maybe.

Move Eq and Ord for Int from GHC.Base to GHC.Classes, so they are not longer orphan.

Put Eq and Ord instances for Arity, Associativity, and Fixity in GHC.Classes, Show instances in GHC.Show, and Read instances in GHC.Read.

Moved the CString functions to GHC.CString in ghc-prim (needed for the new generic deriving mechanism).

Import and re-export GHC.CString from GHC.Base.

Merge branch 'master' of darcs.haskell.org/packages/base into ghc-generics

Solved conflicts:
GHC/Int.hs

Comment the generics stuff instances in GHC.Int, for now.

Add a note about the definition of quot etc

Based on Simon PJ's text in #5161.

Add GHC.Event.getSystemEventManager :: IO (Maybe EventManager)

Performance improvement for division: got rid of an unnecessary branching in cases where the second argument is a constant and is not -1.

monad comprehensions: Group and Zip monad

ticket #4370

Add instances for basic types of the new generic deriving mechanism.

Merge branch 'master' of darcs.haskell.org/packages/base into ghc-generics

Remove a redundant -fno-warn-unused-binds flag

Remove an unnecessary -fno-warn-unused-binds flag

For GHC, implement the Typeable.hs macros using standalone deriving

As well as being more pleasant, this fixes #1841:
    Data.Typeable: Instances of basic types don't provide qualified
    strings to mkTyCon

Fix build on 64bit machines

Part of #5122 "Faster conversion between Rational and Double/Float" fix

From daniel.is.fischer.

Update comment on fmapDefault to note that it only works for Traversable instances with a given definition of traversable, and NOT for instances with only sequenceA given.

Improve docs for GHC.IO.FD.openFile

Initial commit for Pedro's generic-default mechanism

Update source repo location to be the git repo in .cabal file

Removed Show instance for IOCallback and FdData The IOCallback instance conflicts with the more general instance Show (a -> b) defined in Text.Show.Functions

Swap FP_COMMUTE_INT argument order to match AC_COMPUTE_INT

The first 2 arguments are in the opposite order for _AC_COMPUTE_INT

Use FP_COMPUTE_INT rather than AC_COMPUTE_INT

The latter isn't supported by all versions of autoconf (e.g.
whatever SPJ currently has on Windows).

Use _NSGetEnviron on OS X: fixes #2458

Document invariants on mkText{Decoder,Encoder}

Change some uses of CString functions to CAString instead

This prevents potential loops in future if we implement
FFI spec behaviour where the CString family use the locale encoding.

Fix handling of suffixes for GNU iconv

Change debug prints in readTextDevice' to refer to right function

Merge branch 'master' of ssh://darcs.haskell.org/srv/darcs/packages/base

Add .gitignore

Less strict inits and tails

Converted from darcs patches from Bas van Dijk <v.dijk.bas@gmail.com>

Previously: tails _|_ = _|_
Now:        tails _|_ = _|_ : _|_

Previously: inits _|_ = _|_
Now:        inits _|_ = [] : _|_

Tweak alloca docs

Based on a patch from Jason Dagit

Generalize the type of Foreign.Marshal.Utils.maybeNew; fixes trac #5044

git conversion of:
Tue Mar  8 22:31:07 CET 2011  Bas van Dijk <v.dijk.bas@gmail.com>
  * Generalize the type of Foreign.Marshal.Utils.maybeNew
  This makes it consistent with maybeWith

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