This goes with the patch for #1839, #1463

use pathSeparator instead of '/'

cleanup only

FIX #1839, #1463, by supporting ghc-pkg bulk queries with substring matching

   - #1839 asks for a ghc-pkg dump feature, #1463 for the ability
     to query the same fields in several packages at once.

   - this patch enables substring matching for packages in 'list',
     'describe', and 'field', and for modules in find-module. it
     also allows for comma-separated multiple fields in 'field'.
     substring matching can optionally ignore cases to avoid the
     rather unpredictable capitalisation of packages.

   - the patch is not quite as full-featured as the one attached
     to #1839, but avoids the additional dependency on regexps.
     open ended substrings are indicated by '*' (only the three
     forms prefix*, *suffix, *infix* are supported)

   - on windows, the use of '*' for package/module name globbing
     leads to conflicts with filename globbing: by default, windows
     programs are self-globbing, and bash adds another level of
     globbing on top of that. it seems impossible to escape '*'
     from both levels of globbing, so we disable default globbing
     for ghc-pkg and ghc-pkg-inplace. users of bash will still
     have filename globbing available, users of cmd won't.

   - if it is considered necessary to reenable filename globbing
     for cmd users, it should be done selectively, only for
     filename parameters. to this end, the patch includes a
     glob.hs program which simply echoes its parameters after
     filename globbing. see the commented out glob command in
     Main.hs for usage or testing.

   - this covers both tickets, and permits for the most common
     query patterns (finding all packages contributing to the
     System. hierarchy, finding all regex or string packages,
     listing all package maintainers or haddock directories,
     ..), which not only i have wanted to have for a long time.

     examples (the quotes are needed to escape shell-based
     filename globbing and should be omitted in cmd.exe):

       ghc-pkg list '*regex*' --ignore-case
       ghc-pkg list '*string*' --ignore-case
       ghc-pkg list '*gl*' --ignore-case
       ghc-pkg find-module 'Data.*'
       ghc-pkg find-module '*Monad*'
       ghc-pkg field '*' name,maintainer
       ghc-pkg field '*' haddock-html
       ghc-pkg describe '*'

Wibble to the OccurAnal fix for RULEs and loop-breakers

FIX #2049, another problem with the module context on :reload
The previous attempt to fix this (#1873, #1360) left a problem that
occurred when the first :load of the program failed (#2049).

Now I've implemented a different strategy: between :loads, we remember
all the :module commands, and just replay them after a :reload.  This
is in addition to remembering all the package modules added with
:module, which is orthogonal.

This approach is simpler than the previous one, and seems to do the
right thing in all the cases I could think of.  Let's hope this is the
last bug in this series...

Increase the bar for bootstrapping GHC to 6.4 (HEAD only)
 - remove $(ghc_ge_601), $(ghc_ge_602), $(ghc_ge_603)
 - configure now checks the GHC version number
 - there are probably various cleanups that we can now do in compat/
   and compiler/, but I haven't done those yet.

Do not worker/wrapper INLINE things, even if they are in a recursive group

This patch stops the worker/wrapper transform working on an INLINE thing,
even if it's in a recursive group.  It might not be the loop breaker.  Indeed
a recursive group might have no loop breaker, if the only recursion is
through rules.

Again, this change was provoked by one of Roman's NDP libraries.
Specifically the Rec { splitD, splitJoinD } group in
Data.Array.Parallel.Unlifted.Distributed.Arrays

Simon

Make the loop-breaking algorithm a bit more liberal, where RULES are involved

This is another gloss on the now-quite-subtle and heavily-documented algorithm
for choosing loop breakers.

This fix, provoked by Roman's NDP library, makes sure that when we are choosing
a loop breaker we only take into account variables free on the *rhs* of a rule
not the *lhs*.

Most of the new lines are comments!

Fix Trac #2055

Sorry, this was my fault, a consequence of the quasi-quoting patch.

I've added rn062 as a test.

Fix exception message with ghc -e
When running with ghc -e, exceptions should claim to be from the program
that we are running, not ghc.

Fix warnings in main/CmdLineParser

Normalise FilePaths before printing them

Tweak runghc

Fix catching exit exceptions in ghc -e

Typo in phase-control documentation

Fix warnings in main/Main

Support multiple -e flags

Fix ghc -e :main (it was enqueuing the main function, but not running it)

Fix whitespace

Fix giving an error if we are given conflicting mode flags

Add :run and tweak :main
You can now give :main a Haskell [String] as an argument, e.g.
:main ["foo", "bar"]
and :run is a variant that takes the name of the function to run.
Also, :main now obeys the -main-is flag.

Make MacFrameworks a subdirectory of distrib, since it isn't used in the normal building process.

Add scripts for building GMP.framework and GNUreadline.framework (OS X).

Use -framework-path flags during the cc phase.  Fixes trac #1975.

FIX #1821 (Parser or lexer mess-up)

Improve the error when :list can't find any code to show

Fix imports when !DEBUG

Tweak the splitter
We were generating a label ".LnLC7", which the splitter was confusing
with a literal constant (LC). The end result was the assembler tripping
up on ".Ln.text".

Wibble to SetLevels.abstractVars

I've gotten this wrong more than once.  Hopefully this has it nailed.
The issue is that in float-out we must abstract over the correct
variables.

Add quasi-quotation, courtesy of Geoffrey Mainland

This patch adds quasi-quotation, as described in
  "Nice to be Quoted: Quasiquoting for Haskell"
(Geoffrey Mainland, Haskell Workshop 2007)
Implemented by Geoffrey and polished by Simon.

Overview
~~~~~~~~
The syntax for quasiquotation is very similar to the existing
Template haskell syntax:
[$q| stuff |]
where 'q' is the "quoter".  This syntax differs from the paper, by using
a '$' rather than ':', to avoid clashing with parallel array comprehensions.

The "quoter" is a value of type Language.Haskell.TH.Quote.QuasiQuoter, which
contains two functions for quoting expressions and patterns, respectively.

     quote = Language.Haskell.TH.Quote.QuasiQuoter quoteExp quotePat

     quoteExp :: String -> Language.Haskell.TH.ExpQ
     quotePat :: String -> Language.Haskell.TH.PatQ

TEXT is passed unmodified to the quoter. The context of the
quasiquotation statement determines which of the two quoters is
called: if the quasiquotation occurs in an expression context,
quoteExp is called, and if it occurs in a pattern context, quotePat
is called.

The result of running the quoter on its arguments is spliced into
the program using Template Haskell's existing mechanisms for
splicing in code. Note that although Template Haskell does not
support pattern brackets, with this patch binding occurrences of
variables in patterns are supported. Quoters must also obey the same
stage restrictions as Template Haskell; in particular, in this
example quote may not be defined in the module where it is used as a
quasiquoter, but must be imported from another module.

Points to notice
~~~~~~~~~~~~~~~~
* The whole thing is enabled with the flag -XQuasiQuotes

* There is an accompanying patch to the template-haskell library. This
  involves one interface change:
currentModule :: Q String
  is replaced by
location :: Q Loc
  where Loc is a data type defined in TH.Syntax thus:
      data Loc
        = Loc { loc_filename :: String
      , loc_package  :: String
      , loc_module   :: String
      , loc_start    :: CharPos
      , loc_end      :: CharPos }

      type CharPos = (Int, Int) -- Line and character position

  So you get a lot more info from 'location' than from 'currentModule'.
  The location you get is the location of the splice.

  This works in Template Haskell too of course, and lets a TH program
  generate much better error messages.

* There's also a new module in the template-haskell package called
  Language.Haskell.TH.Quote, which contains support code for the
  quasi-quoting feature.

* Quasi-quote splices are run *in the renamer* because they can build
  *patterns* and hence the renamer needs to see the output of running the
  splice.  This involved a bit of rejigging in the renamer, especially
  concerning the reporting of duplicate or shadowed names.

  (In fact I found and removed a few calls to checkDupNames in RnSource
  that are redundant, becuase top-level duplicate decls are handled in
  RnNames.)

lots of portability changes (#1405)

re-recording to avoid new conflicts was too hard, so I just put it
all in one big patch :-(  (besides, some of the changes depended on
each other.)  Here are what the component patches were:

Fri Dec 28 11:02:55 EST 2007  Isaac Dupree <id@isaac.cedarswampstudios.org>
  * document BreakArray better

Fri Dec 28 11:39:22 EST 2007  Isaac Dupree <id@isaac.cedarswampstudios.org>
  * properly ifdef BreakArray for GHCI

Fri Jan  4 13:50:41 EST 2008  Isaac Dupree <id@isaac.cedarswampstudios.org>
  * change ifs on __GLASGOW_HASKELL__ to account for... (#1405)
  for it not being defined. I assume it being undefined implies
  a compiler with relatively modern libraries but without most
  unportable glasgow extensions.

Fri Jan  4 14:21:21 EST 2008  Isaac Dupree <id@isaac.cedarswampstudios.org>
  * MyEither-->EitherString to allow Haskell98 instance

Fri Jan  4 16:13:29 EST 2008  Isaac Dupree <id@isaac.cedarswampstudios.org>
  * re-portabilize Pretty, and corresponding changes

Fri Jan  4 17:19:55 EST 2008  Isaac Dupree <id@isaac.cedarswampstudios.org>
  * Augment FastTypes to be much more complete

Fri Jan  4 20:14:19 EST 2008  Isaac Dupree <id@isaac.cedarswampstudios.org>
  * use FastFunctions, cleanup FastString slightly

Fri Jan  4 21:00:22 EST 2008  Isaac Dupree <id@isaac.cedarswampstudios.org>
  * Massive de-"#", mostly Int# --> FastInt (#1405)

Fri Jan  4 21:02:49 EST 2008  Isaac Dupree <id@isaac.cedarswampstudios.org>
  * miscellaneous unnecessary-extension-removal

Sat Jan  5 19:30:13 EST 2008  Isaac Dupree <id@isaac.cedarswampstudios.org>
  * add FastFunctions

Add missing extendSubst

Oops -- missed this from previous commit; sorry

Add -fspec-inline-join-points to SpecConstr

This patch addresses a problem that Roman found in SpecConstr.  Consider:

foo :: Maybe Int -> Maybe Int -> Int
foo a b = let j b = foo a b
           in
           case b of
             Nothing -> ...
             Just n  -> case a of
                          Just m  -> ... j (Just (n+1)) ...
                          Nothing -> ... j (Just (n-1)) ...

We want to make specialised versions for 'foo' for the patterns
Nothing  (Just v)
(Just a) (Just b)

Two problems, caused by the join point j.  First, j does not
scrutinise b, so j won't be specialised f for the (Just v) pattern.
Second, j is defined where the free var 'a' is not evaluated.

Both are solved by brutally inlining j at its call sites.  This risks
major code bloat, but it's relatively quick to implement.  The flag
-fspec-inline-join-points
causes brutal inlining for a
non-recursive binding
of a function
whose RHS contains calls
of a recursive function

The (experimental) flag is static for now, and I have not even
documented it properly.

Fix references to Filepath

Fix egregious error in earlier "Record evaluated-ness" patch

Eliminate warnings with -DDEBUG

Record evaluated-ness information correctly for strict constructors

The add_evals code in Simplify.simplAlt had bit-rotted.  Example:

  data T a = T !a
  data U a = U !a

  foo :: T a -> U a
  foo (T x) = U x

Here we should not evaluate x before building the U result, because
the x argument of T is already evaluated.

Thanks to Roman for finding this.

In float-out, make sure we abstract over the type variables in the kind of a coercion

I can't remember where this bug showed up, but we were abstracting over a
coercion variable (co :: a ~ T), without also abstracting over 'a'.

The fix is simple.

Fix broken debug warning

Complain sensibly if you try to use scoped type variables in Template Haskell

This fixes Trac #2024; worth merging onto 6.8 branch.

Comments only

Extra instance for Outputable on 5-tuples

Fix the -frule-check pass

Rules for imported things are now kept in the global rule base, not
attached to the global Id.  The rule-check pass hadn't kept up.

This should fix it.

Add dyn-wrapper.c used as cross-plattform launch wrapper for executables using dynamic libraries in non-standard places

Use runPhase_MoveBinary also for generating a dynamic library wrapper

Remove -fhardwire-lib-paths in favour of -dynload sysdep

ghc-inplace defaults to -fhardwire-lib-paths. Change that to -dynload wrapped

Add -dynload flag as dynamic flag.

Add a missing import

Fix Makefile generatin on Windows

Fix slash direction on Windows with the new filePath code

Fix typo

The Core type-matcher should look through PredTypes

The core type-matcher Unify.match was previouly using tcView to expand
types, because it must treat newtypes as distinct from their representation.
But that meant that it also treated the PredType {C Int} as distinct from
its representation type (:TC Int).  And that in turn was causing a rule
not to fire, because the argument types didn't match up.

For this to happen we need to get a situation where we have

  a = :DC blah blah -- Dictionary
  ....(f a).....

Now a has type (:TC Int), bu the RULE for f expects an argument
of type {C Int}.  Roman found that just this was happening.

A bottoming function should have infinite arity

I can't think how this one escaped for so long, but
(error "foo")
should have arityType ABot, just as 'error' itself does.

This improves eta expansion.  I spotted it when looking at the function

  Data.Array.Parallel.Arr.BBArr.writeMBB

in the ndp package.

Add Main.dyn_o deployed into the RTS library dir to linking (see DLLNOTES for rational)

Refactor cross-plattform process spawning from ghc-inplace into shell-tools.c

More verbose error reporting in mk/target.mk

Fix generating dependencies for different ways now we use FilePath
We were making filenames like
dist/build/GHC/Base.p_.o
rather than
dist/build/GHC/Base.p_o

Fix utils/Util for debug build

Give an error if view pattern syntax is used in an expression; fixes #2033

FIX BUILD (Solaris): include fcntl.h for file operations

Fix warning when USE_READLINE is unset

Remove an extra ) that was breaking the build on Windows

Fix warnings in utils/ListSetOps

Fix warnings in utils/Panic

Fix warnings in utils/UniqSet

Fix warnings in utils/Maybes

Fix warnings in utils/BufWrite

Fix warnings in utils/FastTypes
Split off a FastBool module, to avoid a circular import with Panic

Fix warnings in utils/OrdList

Fix warnings in utils/FastMutInt

Fix warnings in utils/State

Only initialise readline if we are connected to a terminal
Patch from Bertram Felgenhauer <int-e@gmx.de>

Fix warnings in utils/Util

Fix warnings in utils/Bag.lhs

Add GMP_INCLUDE_DIRS in a couple of places
Fixes the build on OpenBSD (trac #2009). Based on a patch from kili.

Tweak whitespace in HsExpr

Fix warnings in HsExpr

FilePath fixes

don't initialize readline needlessly
Readline.initialize spills some escape sequences to stdout for some terminal
types, potentially spoiling  ghc -e  output. So don't initialize readline
unless we're working interactively on a terminal.
Patch from Bertram Felgenhauer <int-e@gmx.de>

Fix whitespace

Use System.FilePath

Fix filename completion by adding trailing spaces/slashes manually.

Use command-dependent word break characters for tab completion in ghci.  Fixes bug #998.

Fix 2030: make -XScopedTypeVariables imply -XRelaxedPolyRec

The type checker doesn't support lexically scoped type variables
unless we are using the RelaxedPolyRec option.  Reasons: see
Note [Scoped tyvars] in TcBinds.

So I've changed DynFlags to add this implication, improved the
documentation, and simplified the code in TcBinds somewhat.
(It's longer but only because of comments!)

More refactoring in getCoreToDo

Document -fsimplifier-phases

Add -fsimplifier-phases option

It controls the number of simplifier phases run during optimisation. These are
numbered from n to 1 (by default, n=2). Phase 0 is always run regardless of
this flag. The flag is ignored with -O0 since (practically) no optimisation is
performed in that case.

Refactor getCoreToDo slightly

Fix Trac #2018: float-out was ignoring the kind of a coercion variable

The float-out transformation must handle the case where a coercion
variable is free, which in turn mentions type variables in its kind.
Just like a term variable really.

I did a bit of refactoring at the same time.

Test is tc241

MERGE to stable branch

Make the treatment of equalities more uniform

This patch (which is part of the fix for Trac #2018) makes coercion variables
be handled more uniformly.  Generally, they are treated like dictionaries
in the type checker, not like type variables, but in a couple of places we
were treating them like type variables.  Also when zonking we should use
zonkDictBndr not zonkIdBndr.

Fix Trac #2017

Add -XImpredicativeTypes, and tighten up type-validity checking (cf Trac 2019)

Somehow we didn't have a separate flag for impredicativity; now we do.

Furthermore, Trac #2019 showed up a missing test for monotypes in data
constructor return types.  And I realised that we were even allowing
things like
Num (forall a. a) => ...
which we definitely should not.

This patch insists on monotypes in several places where we were (wrongly)
too liberal before.

Could be merged to 6.8 but no big deal.

pass -no-user-package-conf to ghc-inplace

Fix build: Recent instance shuffling left us with overlapping instances

Add instructions for building docs to README

A little refactoring of GenIfaceEq to make the Outputable instance into H98

Make the instance of DebugNodes more H98-like

change CmmActual, CmmFormal to use a data CmmHinted rather than tuple (#1405)
This allows the instance of UserOfLocalRegs to be within Haskell98, and IMHO
 makes the code a little cleaner generally.
This is one small (though tedious) step towards making GHC's code more
 portable...