Added autoconf magic for size/alignment of some more C types

Changed double quotes to “ and ”. Improvements to Windows
installation instructions.

Update the Hall of Fame.

Stylesheet used for processing SGML. Initially it's identical to the Cygnus
DocBook Tools stylesheet, with %section-autonumber% set to true for HTML, so
that all sections are numbered.

Set SRC_SGML2XXX_OPTS variables rather than SGML2XXX_OPTS

Wrote 4.06 release notes and updated version numbers in the rest of the user
guide.

Added SGMLSTYLESHEET variable and set SGML2XXX_OPTS to -d $(SGMLSTYLESHEET)

Extra install stuff

Increase the heap size for Parser.hs to 80M (for 4.04).

GHC now uses the "Hugs" split function, which is believed to have
better behaviour: it is not unsafe, is deterministic, and works
better with QuickCheck, a major client.

Rational for the Record, quoted from Mark Jones mail on the Hugs list:

[Mark Jones]
A couple of months ago, John Hughes sent me mail about a problem that
he had uncovered with the implementation of the Random library in Hugs.
He had been using the "split" function in an attempt to generate a
stream of random number generators, each of which he hoped would be
different from the others.  But instead he found that he actually
ended with many different copies of the *same* random number generator.
A disappointing, and frustratingly non-random result.

If you don't happen to recall, split is a member of the RandomGen class,
with type RandomGen g => g -> (g,g); it takes a single random number
generator as its argument, and returns a pair of two new generators as
its result.  The only thing that the specification requires is that the
two generators returned are (a) distinct and (b) `independently robust'
from a statistical point of view.  To the best of my knowledge, the
implementation in Hugs meets this modest specification.  Sadly, assuming
only this specification, you cannot write the function that John was
looking for and be sure that it will generate more than two different
generators.

For example, the specification allows even the following trivial
implementation for split:  split _ = (g1, g2), where g1 and g2 are some
arbitrary but constant pair of distinct, and independently robust
generators.  With this implementation, you can split as often as you
want and you'll never get more that two generators.

Hugs and GHC (as far as I can tell) both use definitions of the form:

   split g = (g, f g)

for some function f.  (My understanding of the code in GHC is that it
uses an unsafe function for f, breaking referential transparency; I hope
the optimizer knows about this.)  Note that this definition returns the
argument as a result; the specification doesn't prohibit that; all it
requires is that the two results returned be distinct.  But if you try
to generate a list of n different generators using:

   take n (iterate (fst . split) g)

then you will be sorely disappointed; you might as well have written
replicate n g.  (On the other hand, if you were lucky enough to have
used (snd . split), instead of (fst . split), then you wouldn't have
noticed the problem ...)

I know very little about the mathematics or pragmatics of random
number generators, so I'm not sure that I know how to fix this
problem.  However, starting from this position of ignorance, I have
hacked up a new version of "split" for the standard "StdGen" that
will appear in the next release of Hugs (real soon now!).  Judging
from the tests that I've tried so far, it seems to work much
better than the old version.  That said:

 - Take care if you use Random.split in your programs, because it
   may not do what you expect.

 - There should probably be an errata about this for the Haskell 98
   library report ... if somebody can figure out what it should say.

 - If you use Hugs, be aware that the implementation of Random.split
   was hacked up by someone who has no way of justifying that
   implementation, beyond some simple experiments.

 - If you know something about the mechanics of random number
   generators, here's an area where Haskell specifications and
   implementations could benefit from your knowledge!

All the best,
Mark
[end quote]

Fix bug in async exception handling: the target TSO may have been
relocated as a result of a stack overflow.

Introduce a new StgTSOWhatNext value "ThreadRelocated", which
indicates that this TSO has moved, and the new location is in the link
field.  The garbage collector shorts these out just like indirections.

We have to check for relocated TSOs in killThread# (and any other
primops which take a ThreadId# as an argument - there aren't any at
present).

- FreeBSD 3+ now known as i386-unknown-freebsd
- add alpha-unknown-{linux,freebsd}

freebsd3 ==> freebsd

freebsd3 ==> freebsd

- FreeBSD 3+ is now known as i386-unknown-freebsd (to accomodate
  forthcoming FreeBSD 4.X

-  add alpha-unknown-{linux,freebsd}

Remove potentially confusing references to concurrent bundles.

Fairly grotesque hacks to get the HTML docs, which are now generated
into a subdirectory by db2html, into a binary dist.

remove ghc/docs/libraries from the bindist, add hslibs/doc

trivialCode (x86), when fst arg is immediate, assumed you could reverse
the order of operands, but not true for eg subtract.  Fixed.

Make this test more comprehensive.  We now test

	+,-,div,mod,quot,rem,gcd,lcm

over a range of legal operands, for both Int and Integer.

- add some more test cases, now shows up the minInt bugs in Integer
division.

The minInt saga continues:

 - fix several Integer division-type functions for the
   case when the dividend == S# (-2147483648#).

Pointed out by: Marc Van Dongen <dongen@cs.ucc.ie>

amodeToStix: correctly compute offset for CHARLIKE_closure-s.

Add comment about code generation for debug tracing.

MachCode.stmt2Instrs, StFunBegin, x86 case only: for debugging,
generate trace code to print the name of each labelled code block.

genCCall for x86 assumed that all args were 4 bytes long :-(.
Now works with doubles too.

Remove `libraries' from SUBDIRS

Remove old libraries documentation.

sync up output

syslib fix

Don't spew floating/double literals into assembly output, since this
causes difficulties with FP numbers near the edges of the allowed
ranges.  Instead, convert them to a sequence of bytes and emit those.

syslib fixes.

remove -syslib misc.

fix a few -syslib options.

Don't hold the lock on the Handle while we block waiting for data on a
read.  This is a partial solution to the general problem of holding a
lock on the Handle while in mayBlock.

- ANSIfy
- add a couple of comments about dodgy-looking code

ANSIfy

- context switch after a `par`
- remove some #if 0'd code

non-functional changes that were sitting in my tree.

update a couple of things.