Fix call to StgRun

Modifing these libs so that they also work with StgHugs.

Adding Word8,16,32,64 into Hugs.

These changes are based on the current (Sep99 Hugs) version of Word.

The GHC parts should be unchanged.

- don't hold the scheduler lock while doing the select, since
  we might sit in there for a long time.

- don't need the gettimeofday() hack on Linux, because select
  already returns the unslept time.

remove bogus #include

Add basereg argument to StgRun (not currently handled by anything
except the x86 code, which means SMP only works on x86 at the moment).

Time the shutdown code as well as the initialisation code.  This
figure is sometimes significant for SMP, because the tasks are all
killed by a signal (at the moment) and it might take a while for the
signal to be delivered.

Fix CAF_BLACKHOLE and BLACKHOLE_BQ entry code for SMP case (it was
going into a busy locking state through comparing against the wrong
info pointer)

Remove accidental wibble that made it in with the last commit

make the prototypes of suspendThread and resumeThread available to the RTS.

This commit adds in the current state of our SMP support.  Notably,
this allows the new way 's' to be built, providing support for running
multiple Haskell threads simultaneously on top of any pthreads
implementation, the idea being to take advantage of commodity SMP
boxes.

Don't expect to get much of a speedup yet; due to the excessive
locking required to synchronise access to mutable heap objects, you'll
see a slowdown in most cases, even on a UP machine.  The best I've
seen is a 1.6-1.7 speedup on an example that did no locking (two
optimised nfibs in parallel).

	- new RTS -N flag specifies how many pthreads to start.

	- new driver -smp flag, tells the driver to use way 's'.

	- new compiler -fsmp option (not for user comsumption)
	  tells the compiler not to generate direct jumps to
	  thunk entry code.

	- largely rewritten scheduler

	- _ccall_GC is now done by handing back a "token" to the
	  RTS before executing the ccall; it should now be possible
	  to execute blocking ccalls in the current thread while
	  allowing the RTS to continue running Haskell threads as
	  normal.

	- you can only call thread-safe C libraries from a way 's'
	  build, of course.

Pthread support is still incomplete, and weird things (including
deadlocks) are likely to happen.

expected output

Add simple "raw" style callback example (i.e. not using the FFI).  Just
for testing _ccall_GC really.

Simple example of callback'ery in action

updated with expected-output files

Fix bug in instance Dynamic (Either a b)

Computation of max-stack-use during BCO generation was completely bogus.
Fix it.  Also, add a i_STK_CHECK_big insn with 16-bit opcode.

Correctly evacuate BCOs on the large object list.  Was causing
okeefe_neural to fail.

A regrettably-gigantic commit that puts in place what Simon PJ
has been up to for the last month or so, on and off.

The basic idea was to restore unfoldings to *occurrences* of
variables without introducing a space leak.  I wanted to make
sure things improved relative to 4.04, and that proved depressingly
hard.  On the way I discovered several quite serious bugs in the
simplifier.

Here's a summary of what's gone on.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* No commas between for-alls in RULES.  This makes the for-alls have
  the same syntax as in types.

* Arrange that simplConArgs works in one less pass than before.
  This exposed a bug: a bogus call to completeBeta.

* Add a top-level flag in CoreUnfolding, used in callSiteInline

* Extend w/w to use etaExpandArity, so it does eta/coerce expansion

* Implement inline phases.   The meaning of the inline pragmas is
  described in CoreUnfold.lhs.  You can say things like
	{#- INLINE 2 build #-}
  to mean "inline build in phase 2"

* Don't float anything out of an INLINE.
  Don't float things to top level unless they also escape a value lambda.
	[see comments with SetLevels.lvlMFE
  Without at least one of these changes, I found that
	{-# INLINE concat #-}
	concat = __inline (/\a -> foldr (++) [])
  was getting floated to
	concat = __inline( /\a -> lvl a )
	lvl = ...inlined version of foldr...

  Subsequently I found that not floating constants out of an INLINE
  gave really bad code like
	__inline (let x = e in \y -> ...)
  so I now let things float out of INLINE

* Implement the "reverse-mapping" idea for CSE; actually it turned out to be easier
  to implement it in SetLevels, and may benefit full laziness too.

* It's a good idea to inline inRange. Consider

	index (l,h) i = case inRange (l,h) i of
		  	  True ->  l+i
			  False -> error
  inRange itself isn't strict in h, but if it't inlined then 'index'
  *does* become strict in h.  Interesting!

* Big change to the way unfoldings and occurrence info is propagated in the simplifier
  The plan is described in Subst.lhs with the Subst type
  Occurrence info is now in a separate IdInfo field than user pragmas

* I found that
	(coerce T (coerce S (\x.e))) y
  didn't simplify in one round. First we get to
	(\x.e) y
  and only then do the beta. Solution: cancel the coerces in the continuation

* Amazingly, CoreUnfold wasn't counting the cost of a function an application.

* Disable rules in initial simplifier run.  Otherwise full laziness
  doesn't get a chance to lift out a MFE before a rule (e.g. fusion)
  zaps it.  queens is a case in point

* Improve float-out stuff significantly.  The big change is that if we have

	\x -> ... /\a -> ...let p = ..a.. in let q = ...p...

  where p's rhs doesn't x, we abstract a from p, so that we can get p past x.
  (We did that before.)  But we also substitute (p a) for p in q, and then
  we can do the same thing for q.  (We didn't do that, so q got stuck.)
  This is much better.  It involves doing a substitution "as we go" in SetLevels,
  though.

fromInt stuff and other wibbles

Minor tweaks to intro, and description of RULES

ppr change that should have been included with prev absCSyn/ commit

Increase NUM_TEXT to 100000 so okeefe_neural will parse.

Nuke #if OVERLOADED_CONSTANTS, since H98 requires it by default.

Fix codegen bug causing cg028.hs to fail.  namePmDouble was not bound
to anything, which caused translations of patterns containing doubles
to contain NILs.  Also bound namePmInteger since it didn't seem to be
bound to anything.

updated

formatRealFloat: Fixed some e==0 confusion in the default case for FFExponent

wibble in derive.c

Changing stdout's buffering. fflush in the program does not flush
the dll's private buffer space on Win32.

Adding commands to generate the std H98 libs for STG Hugs.

minor tweaks to do with H98 (like sequence => sequence_, etc)
Removing the lib/*hs standard libs to make way for the automatically
generated ones.

Changing to use the new IO primitives.
Addr is no longer a synonym of Int.

Adding type signature to main.

To workaround gcc/egcs bugs re: handling of non-toplevel "extern" decls,
lift them out to the top. i.e., extend mechanism by which "typedefs"
are lifted out to the toplevel (for the same reasons) to also encompass
"extern"s.

Note: the default is not to emit an "extern" decl for every _ccall_,
as this runs the chance of (trivially) conflicting with header file
includes. So, to enable, use -optC-femit-extern-decls.

#include wibble

portability wibble

Minor efficiency improvements to Prelude I/O functions.

Pure Win32 builds doesn't support non-blocking IO

wibble

attach version info

s/TargetPlatform/TARGETPLATFORM/g