205 lines
9.7 KiB
Nix
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";
|
|
};
|
|
};
|
|
}
|