nixpkgs/pkgs/development/compilers/ghcs/default.nix
Marc Weber d884e1d0a6 fix c -> Cabal-1.2.3.0 the lib is found again
svn path=/nixpkgs/trunk/; revision=10669
2008-02-13 21:21:20 +00:00

205 lines
9.7 KiB
Nix

{ ghcPkgUtil, gnum4, perl, ghcboot, stdenv, fetchurl, recurseIntoAttrs, gmp, readline, lib, annotatedDerivations, hasktags, ctags } :
with annotatedDerivations;
rec {
/* What's in here?
Goal: really pure GHC. This means put every library into its each package.conf
and add all together using GHC_PACKAGE_PATH
First I've tried separating the build of ghc from it's lib. It hase been to painful. I've failed.
Now there is nix_ghc_pkg_tool.hs which just takes the installed package.conf
and creates a new package db file for each contained package.
The final attribute set looks similar to this:
ghc, core_libs and extra_libraries will then be used to build all the ohter packages availible on hackege..
(There is much left to be done)
ghcAndLibraries = {
ghc68 = {
ghc = {
src = "The compiler source"
extra_src = "source of extra libraries"
version = "GHC version as string"
}
core_libs = [ libs distributed the ghc core (see libraries/core-packages ];
extra_libraries = [ libraries contained extra_src ];
};
ghc66 = {
roughly the same
};
}
*/
#this only works for ghc-6.8 right now
ghcAndLibraries = { version, src /* , core_libraries, extra_libraries */
, extra_src }:
recurseIntoAttrs ( rec {
inherit src extra_src version;
ghc = stdenv.mkDerivation {
name = "ghc-"+version;
inherit src ghcboot gmp version;
buildInputs = [readline perl gnum4 gmp];
preConfigure = "
chmod u+x rts/gmp/configure
# still requires a hack for ncurses
sed -i \"s|^\(library-dirs.*$\)|\1 \\\"$ncurses/lib\\\"|\" libraries/readline/package.conf.in
";
# TODO add unique (filter duplicates?) shouldn't be there?
nix_ghc_pkg_tool = ./nix_ghc_pkg_tool.hs;
configurePhase = "./configure"
+" --prefix=\$out "
+" --with-ghc=\$ghcboot/bin/ghc"
+" --with-gmp-libraries=$gmp/lib"
+" --with-gmp-includes=${gmp}/include"
+" --with-readline-libraries=\"$readline/lib\"";
# now read the main package.conf and create a single package db file for each of them
# Also create setup hook.
# note : I don't know yet wether it's a good idea to have RUNGHC.. It's faster
# but you can't pass packages, can you?
postInstall = "
cp \$nix_ghc_pkg_tool nix_ghc_pkg_tool.hs
\$out/bin/ghc-\$version --make -o nix_ghc_pkg_tool nix_ghc_pkg_tool.hs;
./nix_ghc_pkg_tool split \$out/lib/ghc-\$version/package.conf \$out/lib/ghc-\$version
cp nix_ghc_pkg_tool \$out/bin
if test -x \$out/bin/runghc; then
RUNHGHC=\$out/bin/runghc # > ghc-6.7/8 ?
else
RUNHGHC=\$out/bin/runhaskell # ghc-6.6 and prior
fi
ensureDir \$out/nix-support
sh=\$out/nix-support/setup-hook
echo \"RUNHGHC=\$RUNHGHC\" >> \$sh
";
};
core_libs = rec {
# name (using lowercase letters everywhere because using installing packages having different capitalization is discouraged) - this way there is not that much to remember?
cabal_darcs_name = "cabal-darcs";
# introducing p here to speed things up.
# It merges derivations (defined below) and additional inputs. I hope that using as few nix functions as possible results in greates speed?
# unfortunately with x; won't work because it forces nix to evaluate all attributes of x which would lead to infinite recursion
pkgs = let x = derivations; in {
# ghc extra packages
cabal = { name = "Cabal-1.2.3.0"; srcDir = "libraries/Cabal";
deps = [x.base x.pretty x.old_locale x.old_time
x.directory x.unix x.process x.array x.containers
x.rts x.filepath ]; };
array = { name = "array-0.1.0.0"; srcDir = "libraries/array";
deps = [x.base ]; };
base = { name = "base-3.0.1.0"; srcDir = "libraries/base";
deps = [x.rts ]; };
bytestring = { name = "bytestring-0.9.0.1"; srcDir = "libraries/bytestring";
deps = [ x.base x.array ];};
containers = { name = "containers-0.1.0.1"; srcDir = "libraries/containers";
deps = [ x.base x.array ];};
directory = { name = "directory-1.0.0.0"; srcDir = "libraries/directory";
deps = [ x.base x.old_locale x.old_time x.filepath ];};
filepath = { name = "filepath-1.1.0.0"; srcDir = "libraries/filepath";
deps = [ x.base ];};
ghc = { name = "ghc-${version}"; srcDir = "libraries/Cabal";
deps = [ x.base x.old_locale x.old_time x.filepath
x.directory x.array x.containers x.hpc x.bytestring
x.pretty x.packedstring x.template_haskell x.unix
x.process x.readline x.cabal x.random x.haskell98 ]; };
haskell98 = { name = "haskell98-1.0.1.0"; srcDir = "libraries/haskell98";
deps = [ x.base x.old_locale x.old_time x.filepath
x.directory x.random x.unix x.process x.array]; };
hpc = { name = "hpc-0.5.0.0"; srcDir = "libraries/hpc";
deps = [ x.base x.old_locale x.old_time x.filepath
x.directory x.array x.containers ]; };
old_locale = { name = "old-locale-1.0.0.0"; srcDir = "libraries/old-locale";
deps = [ x.base ]; };
old_time = { name = "old-time-1.0.0.0"; srcDir = "libraries/old-time";
deps = [ x.base x.old_locale ];};
packedstring = { name = "packedstring-0.1.0.0"; srcDir = "libraries/packedstring";
deps = [ x.base x.array ];};
pretty = { name = "pretty-1.0.0.0"; srcDir = "libraries/pretty";
deps = [ x.base ];};
process = { name = "process-1.0.0.0"; srcDir = "libraries/process";
deps = [ x.base x.old_locale x.old_time x.filepath
x.directory x.unix ]; };
random = { name = "random-1.0.0.0"; srcDir = "libraries/random";
deps = [ x.base x.old_locale x.old_time ]; };
readline = { name = "readline-1.0.1.0"; srcDir = "libraries/readline";
deps = [ x.base x.old_locale x.old_time x.filepath
x.directory x.unix x.process ];};
rts = rec {
name = "rts-1.0"; srcDir = "rts"; # TODO: Doesn't have .hs files so I should use ctags if creating tags at all
deps = [];
createTagFiles = [
{ name = "${name}_haskell_tags";
tagCmd = "${toString ctags}/bin/ctags -R .;mv tags \$TAG_FILE"; }
];
};
template_haskell = { name = "template-haskell-2.2.0.0"; srcDir = "libraries/template-haskell";
deps = [ x.base x.pretty x.array x.packedstring x.containers ];};
unix = { name = "unix-2.3.0.0"; srcDir = "libraries/unix";
deps = [ x.base x.old_locale x.old_time x.filepath x.directory ];};
};
toDerivation = attrs : with attrs;
rec {
inherit name;
#aDeps = concatLists ( catAttrs ( subsetmap id args [ "buildInputs" "propagatedBuildInputs" ] ) );
aDeps = deps;
# dummy derivation, only creates setup-hook for package database located in the ghc derivation
aDeriv = stdenv.mkDerivation {
inherit name;
phases = "buildPhase fixupPhase";
buildInputs = [ ghcPkgUtil ];
propagatedBuildInputs = [ ghc ] ++ map delAnnotation attrs.deps;
buildPhase = "setupHookRegisteringPackageDatabase \"${ghc}/lib/ghc-${ghc.version}/${name}.conf\"";
};
sourceWithTags = {
src = ghc.src;
inherit srcDir;
name = name + "-src-with-tags";
createTagFiles = lib.maybeAttr "createTagFiles" [
{ name = "${name}_haskell_tags";
tagCmd = "${toString hasktags}/bin/hasktags-modified --ctags `find . -type f -name \"*.*hs\"`; sort tags > \$TAG_FILE"; }
] attrs;
};
};
derivations = with lib; builtins.listToAttrs (lib.concatLists ( lib.mapRecordFlatten
( n : attrs : let d = (toDerivation attrs); in [ (nv n d) (nv attrs.name d) ] ) pkgs ) );
}.derivations;
});
ghc68 = ghcAndLibraries rec {
version = "6.8.2";
src = fetchurl {
#url = http://www.haskell.org/ghc/dist/stable/dist/ghc-6.8.0.20071004-src.tar.bz2;
#sha256 = "1yyl7sxykmvkiwfxkfzpqa6cmgw19phkyjcdv99ml22j16wli63l";
url = "http://www.haskell.org/ghc/dist/stable/dist/ghc-${version}-src.tar.bz2";
md5 = "745c6b7d4370610244419cbfec4b2f84";
#url = http://www.haskell.org/ghc/dist/stable/dist/ghc-6.8.20070912-src.tar.bz2;
#sha256 = "1b1gvi7hc7sc0fkh29qvzzd5lgnlvdv3ayiak4mkfnzkahvmq85s";
};
extra_src = fetchurl {
url = "http://www.haskell.org/ghc/dist/stable/dist/ghc-${version}-src-extralibs.tar.bz2";
sha256 = "044mpbzpkbxcnqhjnrnmjs00mr85057d123rrlz2vch795lxbkcn";
#url = http://www.haskell.org/ghc/dist/stable/dist/ghc-6.8.20070912-src-extralibs.tar.bz2;
#sha256 = "0py7d9nh3lkhjxr3yb3n9345d0hmzq79bi40al5rcr3sb84rnp9r";
};
};
}