public/nixpkgs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' into x-updates

Browse Source
This commit is contained in:
Mathijs Kwik
2013-11-01 08:35:16 +01:00
parent f445474d33 b6519f08da
commit f4903d890e
1354 changed files with 62426 additions and 7849 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
pkgs/development/compilers/aldor/default.nix
View File

@@ -29,7 +29,7 @@ stdenv.mkDerivation {
meta = {
homepage = "http://www.aldor.org/";
description = "Aldor is a programming language with an expressive type system";
description = "Programming language with an expressive type system";
license = stdenv.lib.licenses.asl20;
longDescription = ''

19
pkgs/development/compilers/ats2/default.nix Normal file
View File

@@ -0,0 +1,19 @@
{ stdenv, fetchurl, gmp }:
let version = "0.0.3"; in stdenv.mkDerivation {
name = "ats2-postiats-${version}";
src = fetchurl {
url = "mirror://sourceforge/ats2-lang/ATS2-Postiats-${version}.tgz";
sha256 = "0hq63zrmm92j5ffnsmylhhllm8kgjpjkaj4xvzz1zlshz39lijxp";
};
buildInputs = [ gmp ];
meta = {
description = "A statically typed programming language that unifies implementation with formal specification";
homepage = http://www.ats-lang.org/;
license = stdenv.lib.licenses.gpl3Plus;
maintainers = [ stdenv.lib.maintainers.shlevy ];
};
}

2
pkgs/development/compilers/clean/default.nix
View File

@@ -34,7 +34,7 @@ stdenv.mkDerivation rec {
'';
meta = {
description = "Clean is a general purpose, state-of-the-art, pure and lazy functional programming language.";
description = "General purpose, state-of-the-art, pure and lazy functional programming language";
longDescription = ''
Clean is a general purpose, state-of-the-art, pure and lazy functional
programming language designed for making real-world applications. Some

12
pkgs/development/compilers/edk2/default.nix
View File

@@ -1,4 +1,4 @@
{ stdenv, fetchsvn, libuuid, pythonFull, iasl }:
{ stdenv, fetchgit, libuuid, pythonFull, iasl }:
let
@@ -10,12 +10,12 @@ else
throw "Unsupported architecture";
edk2 = stdenv.mkDerivation {
name = "edk2-2013-03-19";
name = "edk2-2013-10-09";
src = fetchsvn {
url = https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2;
rev = "14211";
sha256 = "1rhrv7cyazb1d4gw3s8fv0c245iankvb9pqx6nngbkkxkcswvnw7";
src = fetchgit {
url = git://github.com/tianocore/edk2;
rev = "5bcb62a4098c9bde9be6af0833a025adc768e08d";
sha256 = "3e2958877061bf6bbfb28b150743d7244486929c1c320bdb1ff2586774aa042a";
};
buildInputs = [ libuuid pythonFull ];

15
pkgs/development/compilers/elm/elm.nix
View File

@@ -1,17 +1,20 @@
{ cabal, binary, blazeHtml, blazeMarkup, cmdargs, filepath, hjsmin
, indents, mtl, pandoc, parsec, transformers, unionFind, uniplate
{ cabal, aeson, aesonPretty, binary, blazeHtml, blazeMarkup
, cmdargs, filepath, HTF, indents, languageEcmascript, mtl, pandoc
, parsec, text, transformers, unionFind, uniplate
}:
cabal.mkDerivation (self: {
pname = "Elm";
version = "0.9.0.2";
sha256 = "0yr395wsj0spi6h9d6lm5hvdryybpf8i1qpv4gz9dk0bwlyc8iwh";
version = "0.10.0.1";
sha256 = "1r7z2fw9v6ngr9w4lmj1l6sc78rmxvqkqlxv4a9yc5jm80k3ar0i";
isLibrary = true;
isExecutable = true;
buildDepends = [
binary blazeHtml blazeMarkup cmdargs filepath hjsmin indents mtl
pandoc parsec transformers unionFind uniplate
aeson aesonPretty binary blazeHtml blazeMarkup cmdargs filepath
indents languageEcmascript mtl pandoc parsec text transformers
unionFind uniplate
];
testDepends = [ HTF ];
doCheck = false;
meta = {
homepage = "http://elm-lang.org";

4
pkgs/development/compilers/ghc/6.10.1-binary.nix
View File

@@ -36,10 +36,10 @@ stdenv.mkDerivation rec {
''
mkdir "$TMP/bin"
for i in strip; do
echo '#!/bin/sh' >> "$TMP/bin/$i"
echo '#! ${stdenv.shell}' > "$TMP/bin/$i"
chmod +x "$TMP/bin/$i"
PATH="$TMP/bin:$PATH"
done
PATH="$TMP/bin:$PATH"
'' +
# On Linux, use patchelf to modify the executables so that they can
# find editline/gmp.

4
pkgs/development/compilers/ghc/6.10.2-binary.nix
View File

@@ -30,10 +30,10 @@ stdenv.mkDerivation rec {
''
mkdir "$TMP/bin"
for i in strip; do
echo '#!/bin/sh' >> "$TMP/bin/$i"
echo '#! ${stdenv.shell}' > "$TMP/bin/$i"
chmod +x "$TMP/bin/$i"
PATH="$TMP/bin:$PATH"
done
PATH="$TMP/bin:$PATH"
'' +
# On Linux, use patchelf to modify the executables so that they can
# find editline/gmp.

4
pkgs/development/compilers/ghc/6.12.1-binary.nix
View File

@@ -28,10 +28,10 @@ stdenv.mkDerivation rec {
''
mkdir "$TMP/bin"
for i in strip; do
echo '#!/bin/sh' >> "$TMP/bin/$i"
echo '#! ${stdenv.shell}' > "$TMP/bin/$i"
chmod +x "$TMP/bin/$i"
PATH="$TMP/bin:$PATH"
done
PATH="$TMP/bin:$PATH"
'' +
# We have to patch the GMP paths for the integer-gmp package.
''

4
pkgs/development/compilers/ghc/7.0.4-binary.nix
View File

@@ -38,10 +38,10 @@ stdenv.mkDerivation rec {
''
mkdir "$TMP/bin"
for i in strip; do
echo '#!/bin/sh' >> "$TMP/bin/$i"
echo '#! ${stdenv.shell}' > "$TMP/bin/$i"
chmod +x "$TMP/bin/$i"
PATH="$TMP/bin:$PATH"
done
PATH="$TMP/bin:$PATH"
'' +
# We have to patch the GMP paths for the integer-gmp package.
''

4
pkgs/development/compilers/ghc/7.4.2-binary.nix
View File

@@ -38,10 +38,10 @@ stdenv.mkDerivation rec {
''
mkdir "$TMP/bin"
for i in strip; do
echo '#!/bin/sh' >> "$TMP/bin/$i"
echo '#! ${stdenv.shell}' > "$TMP/bin/$i"
chmod +x "$TMP/bin/$i"
PATH="$TMP/bin:$PATH"
done
PATH="$TMP/bin:$PATH"
'' +
# We have to patch the GMP paths for the integer-gmp package.
''

1
pkgs/development/compilers/ghc/7.4.2.nix
View File

@@ -22,6 +22,7 @@ stdenv.mkDerivation rec {
preConfigure = ''
echo "${buildMK}" > mk/build.mk
sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure
export NIX_LDFLAGS="$NIX_LDFLAGS -rpath $out/lib/ghc-${version}"
'';
configureFlags=[

5
pkgs/development/compilers/ghc/7.6.3.nix
View File

@@ -22,11 +22,10 @@ stdenv.mkDerivation rec {
preConfigure = ''
echo "${buildMK}" > mk/build.mk
sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure
export NIX_LDFLAGS="$NIX_LDFLAGS -rpath $out/lib/ghc-${version}"
'';
configureFlags = [
"--with-gcc=${stdenv.gcc}/bin/gcc"
];
configureFlags = "--with-gcc=${stdenv.gcc}/bin/gcc";
# required, because otherwise all symbols from HSffi.o are stripped, and
# that in turn causes GHCi to abort

5
pkgs/development/compilers/ghc/head.nix
View File

@@ -1,12 +1,12 @@
{ stdenv, fetchurl, ghc, perl, gmp, ncurses }:
stdenv.mkDerivation rec {
version = "7.7.20130816";
version = "7.7.20130828";
name = "ghc-${version}";
src = fetchurl {
url = "http://darcs.haskell.org/ghcBuilder/uploads/tn23/${name}-src.tar.bz2";
sha256 = "0w636gfjn3xigrlj31z4hy9kv44svyifsqcshrq95qxijx396j5m";
sha256 = "180nkd77kz3mv4g7yq8ipx34p5q8k714l0z2527y49lghy118jzv";
};
buildInputs = [ ghc perl gmp ncurses ];
@@ -22,6 +22,7 @@ stdenv.mkDerivation rec {
preConfigure = ''
echo "${buildMK}" > mk/build.mk
sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure
export NIX_LDFLAGS="$NIX_LDFLAGS -rpath $out/lib/ghc-${version}"
'';
configureFlags = "--with-gcc=${stdenv.gcc}/bin/gcc";

141
pkgs/development/compilers/ghc/with-packages.nix
View File

@@ -1,127 +1,42 @@
{stdenv, ghc, packages ? [], makeWrapper}:
{ stdenv, ghc, packages, buildEnv, makeWrapper }:
stdenv.mkDerivation rec {
assert packages != [];
let
ghc761OrLater = stdenv.lib.versionOlder "7.6.1" ghc.version;
packageDBFlag = if ghc761OrLater then "--package-db" else "--package-conf";
libDir = "$out/lib/ghc-${ghc.version}";
packageCfgDir = "${libDir}/package.conf.d";
in
buildEnv {
name = "haskell-env-${ghc.name}";
allPackages = stdenv.lib.closePropagation packages;
buildInputs = allPackages ++ [makeWrapper];
propagatedBuildInputs = packages;
unpackPhase = "true";
installPhase = ''
numversion=$(${ghc}/bin/ghc --numeric-version)
majorversion=''${numversion%%.*}
minorversion=''${numversion#*.}
minorversion=''${minorversion%%.*}
if [[ $majorversion -gt 6 ]] && [[ $minorversion -gt 4 ]]; then
globalConf="--global-package-db"
else
globalConf="--global-conf"
fi
originalTopDir="${ghc}/lib/ghc-${ghc.version}"
originalPkgDir="$originalTopDir/package.conf.d"
linkedTopDir="$out/lib"
linkedPkgDir="$linkedTopDir/package.conf.d"
mkdir -p $out/bin
mkdir -p $linkedTopDir
mkdir -p $linkedPkgDir
echo "Linking GHC core libraries:"
echo -n "Linking $originalTopDir "
for f in "$originalTopDir/"*; do
if test -f $f; then
ln -s $f $linkedTopDir
echo -n .
fi
done
echo
echo -n "Linking $originalPkgDir "
for f in "$originalPkgDir/"*.conf; do
ln -s $f $linkedPkgDir
echo -n .
done
echo
echo "Linking selected packages and dependencies:"
for currentPath in ${stdenv.lib.concatStringsSep " " allPackages}; do
currentPkgDir="$currentPath/lib/ghc-pkgs/ghc-${ghc.version}"
# Check if current path is a Cabal package for the current GHC
if test -d $currentPkgDir; then
echo -n "Linking $currentPath "
for f in "$currentPath/bin/"*; do
ln -s $f $out/bin
echo -n .
done
for f in "$currentPath/etc/bash_completion.d/"*; do
mkdir -p $out/etc/bash_completion.d
ln -s $f $out/etc/bash_completion.d/
echo -n .
done
for s in 1 2 3 4 5 6 7 8 9; do
for f in "$currentPath/share/man/man$s/"*; do
mkdir -p $out/share/man/man$s
ln -sv $f $out/share/man/man$s/
echo -n .
done
done
for f in "$currentPath/share/emacs/site-lisp/"*; do
mkdir -p $out/share/emacs/site-lisp
ln -s $f $out/share/emacs/site-lisp/
echo -n .
done
for f in "$currentPath/share/ghci/"*; do
mkdir -p $out/share/ghci
ln -s $f $out/share/ghci/
echo -n .
done
for f in "$currentPkgDir/"*.conf; do
ln -s $f $linkedPkgDir
echo -n .
done
echo
fi
done
echo -n "Generating package cache "
${ghc}/bin/ghc-pkg $globalConf $linkedPkgDir recache
echo .
echo -n "Generating wrappers "
paths = stdenv.lib.filter (x: x ? ghc) (stdenv.lib.closePropagation packages) ++ [ghc];
postBuild = ''
. ${makeWrapper}/nix-support/setup-hook
for prg in ghc ghci ghc-${ghc.version} ghci-${ghc.version}; do
# The NIX env-vars are picked up by our patched version of ghc-paths.
makeWrapper ${ghc}/bin/$prg $out/bin/$prg \
--add-flags "-B$linkedTopDir" \
--set "NIX_GHC" "$out/bin/ghc" \
--set "NIX_GHCPKG" "$out/bin/ghc-pkg" \
--set "NIX_GHC_LIBDIR" "$linkedTopDir"
echo -n .
rm -f $out/bin/$prg
makeWrapper ${ghc}/bin/$prg $out/bin/$prg \
--add-flags '"-B$NIX_GHC_LIBDIR"' \
--set "NIX_GHC" "$out/bin/ghc" \
--set "NIX_GHCPKG" "$out/bin/ghc-pkg" \
--set "NIX_GHC_LIBDIR" "${libDir}"
done
for prg in runghc runhaskell; do
makeWrapper ${ghc}/bin/$prg $out/bin/$prg --add-flags "-f $out/bin/ghc"
echo -n .
rm -f $out/bin/$prg
makeWrapper ${ghc}/bin/$prg $out/bin/$prg \
--add-flags "-f $out/bin/ghc" \
--set "NIX_GHC" "$out/bin/ghc" \
--set "NIX_GHCPKG" "$out/bin/ghc-pkg" \
--set "NIX_GHC_LIBDIR" "${libDir}"
done
for prg in ghc-pkg ghc-pkg-${ghc.version}; do
makeWrapper ${ghc}/bin/$prg $out/bin/$prg --add-flags "$globalConf $linkedPkgDir"
echo -n .
rm -f $out/bin/$prg
makeWrapper ${ghc}/bin/$prg $out/bin/$prg --add-flags "${packageDBFlag} ${packageCfgDir}"
done
for prg in hp2ps hpc hasktags hsc2hs haddock haddock-${ghc.version}; do
if test -x ${ghc}/bin/$prg -a ! -x $out/bin/$prg; then
ln -s ${ghc}/bin/$prg $out/bin/$prg && echo -n .
fi
done
echo
$out/bin/ghc-pkg recache
'';
meta = ghc.meta;
}

96
pkgs/development/compilers/ghc/wrapper.nix
View File

@@ -1,10 +1,53 @@
{ stdenv, ghc, makeWrapper, coreutils, forUserEnv ? false }:
{ stdenv, ghc, makeWrapper, coreutils, writeScript }:
let
ghc761OrLater = !stdenv.lib.versionOlder ghc.version "7.6.1";
packageDBFlag = if ghc761OrLater then "-package-db" else "-package-conf";
GHCGetPackages = writeScript "ghc-get-packages.sh" ''
#! ${stdenv.shell}
# Usage:
# $1: version of GHC
# $2: invocation path of GHC
# $3: prefix
version="$1"
if test -z "$3"; then
prefix="${packageDBFlag} "
else
prefix="$3"
fi
PATH="$2:$PATH"
IFS=":"
for p in $PATH; do
PkgDir="$p/../lib/ghc-$version/package.conf.d"
for i in "$PkgDir/"*.installedconf; do
# output takes place here
test -f $i && echo -n " $prefix$i"
done
done
test -f "$2/../lib/ghc-$version/package.conf" && echo -n " $prefix$2/../lib/ghc-$version/package.conf"
'';
GHCPackages = writeScript "ghc-packages.sh" ''
#! ${stdenv.shell} -e
declare -A GHC_PACKAGES_HASH # using bash4 hashs to get uniq paths
for arg in $(${GHCGetPackages} ${ghc.version} "$(dirname $0)"); do
case "$arg" in
${packageDBFlag}) ;;
*)
CANONICALIZED="$(${coreutils}/bin/readlink -f -- "$arg")"
GHC_PACKAGES_HASH["$CANONICALIZED"]= ;;
esac
done
for path in ''${!GHC_PACKAGES_HASH[@]}; do
echo -n "$path:"
done
'';
in
stdenv.mkDerivation ({
stdenv.mkDerivation {
name = "ghc-${ghc.version}-wrapper";
buildInputs = [makeWrapper];
@@ -12,53 +55,32 @@ stdenv.mkDerivation ({
unpackPhase = "true";
installPhase = ''
runHook preInstall
mkdir -p $out/bin
cp $GHCGetPackages $out/bin/ghc-get-packages.sh
chmod 755 $out/bin/ghc-get-packages.sh
for prg in ghc ghci ghc-${ghc.version} ghci-${ghc.version}; do
makeWrapper $ghc/bin/$prg $out/bin/$prg --add-flags "\$($out/bin/ghc-get-packages.sh ${ghc.version} \"\$(dirname \$0)\")"
makeWrapper $ghc/bin/$prg $out/bin/$prg --add-flags "\$(${GHCGetPackages} ${ghc.version} \"\$(dirname \$0)\")"
done
for prg in runghc runhaskell; do
makeWrapper $ghc/bin/$prg $out/bin/$prg --add-flags "\$($out/bin/ghc-get-packages.sh ${ghc.version} \"\$(dirname \$0)\" \" ${packageDBFlag} --ghc-arg=\")"
makeWrapper $ghc/bin/$prg $out/bin/$prg --add-flags "\$(${GHCGetPackages} ${ghc.version} \"\$(dirname \$0)\" \" ${packageDBFlag} --ghc-arg=\")"
done
for prg in ghc-pkg ghc-pkg-${ghc.version}; do
makeWrapper $ghc/bin/$prg $out/bin/$prg --add-flags "\$($out/bin/ghc-get-packages.sh ${ghc.version} \"\$(dirname \$0)\" -${packageDBFlag}=)"
makeWrapper $ghc/bin/$prg $out/bin/$prg --add-flags "\$(${GHCGetPackages} ${ghc.version} \"\$(dirname \$0)\" -${packageDBFlag}=)"
done
for prg in hp2ps hpc hasktags hsc2hs; do
test -x $ghc/bin/$prg && ln -s $ghc/bin/$prg $out/bin/$prg
done
cat >> $out/bin/ghc-packages << EOF
#! /bin/bash -e
declare -A GHC_PACKAGES_HASH # using bash4 hashs to get uniq paths
for arg in \$($out/bin/ghc-get-packages.sh ${ghc.version} \"\$(dirname \$0)\"); do
case "\$arg" in
${packageDBFlag}) ;;
*)
CANONICALIZED="\$(${stdenv.lib.optionalString stdenv.isDarwin "${coreutils}/bin/"}readlink -f "\$arg")"
GHC_PACKAGES_HASH["\$CANONICALIZED"]= ;;
esac
done
for path in \''${!GHC_PACKAGES_HASH[@]}; do
echo -n "\$path:"
done
EOF
chmod +x $out/bin/ghc-packages
mkdir -p $out/nix-support
ln -s $out/nix-support/propagated-build-inputs $out/nix-support/propagated-user-env-packages
mkdir -p $out/share/doc
ln -s $ghc/lib $out/lib
ln -s $ghc/share/doc/ghc $out/share/doc/ghc-${ghc.version}
runHook postInstall
'';
GHCGetPackages = ./ghc-get-packages.sh;
inherit ghc;
inherit (ghc) meta;
ghcVersion = ghc.version;
} // (stdenv.lib.optionalAttrs ghc761OrLater { preFixup = "sed -i -e 's|-package-conf|${packageDBFlag}|' $out/bin/ghc-get-packages.sh"; })
// (stdenv.lib.optionalAttrs forUserEnv {
postFixup= ''
ln -s $ghc/lib $out/lib;
mkdir -p $out/share/doc
ln -s $ghc/share/doc/ghc $out/share/doc/ghc-${ghc.version}
'';
}))
inherit ghc GHCGetPackages GHCPackages;
inherit (ghc) meta version;
}

2
pkgs/development/compilers/gwt/2.4.0.nix
View File

@@ -18,6 +18,6 @@ stdenv.mkDerivation {
meta = {
homepage = http://code.google.com/webtoolkit/;
description = "Google Web Toolkit (GWT) is a development toolkit for building and optimizing complex browser-based applications.";
description = "Google Web Toolkit (GWT) is a development toolkit for building and optimizing complex browser-based applications";
};
}

21
pkgs/development/compilers/idris/default.nix
View File

@@ -1,20 +1,21 @@
{ cabal, ansiTerminal, binary, boehmgc, Cabal, filepath, gmp, happy
, haskeline, languageJava, libffi, llvmGeneral, llvmGeneralPure
, mtl, parsec, parsers, split, text, time, transformers, trifecta
, unorderedContainers, utf8String, vector, vectorBinaryInstances
{ cabal, ansiTerminal, ansiWlPprint, binary, boehmgc, Cabal
, filepath, gmp, happy, haskeline, languageJava, libffi
, llvmGeneral, llvmGeneralPure, mtl, parsec, parsers, split, text
, time, transformers, trifecta, unorderedContainers, utf8String
, vector, vectorBinaryInstances
}:
cabal.mkDerivation (self: {
pname = "idris";
version = "0.9.9.2";
sha256 = "0xfwnlf3jca64i4piyx9scmk4z8f6rak2cvrcjwji505a9vaa0rw";
version = "0.9.9.3";
sha256 = "1l19xx0xbcwlnnh2w0rmri7wwixffzfrafpbji64nwyx1awz4iab";
isLibrary = false;
isExecutable = true;
buildDepends = [
ansiTerminal binary Cabal filepath haskeline languageJava libffi
llvmGeneral llvmGeneralPure mtl parsec parsers split text time
transformers trifecta unorderedContainers utf8String vector
vectorBinaryInstances
ansiTerminal ansiWlPprint binary Cabal filepath haskeline
languageJava libffi llvmGeneral llvmGeneralPure mtl parsec parsers
split text time transformers trifecta unorderedContainers
utf8String vector vectorBinaryInstances
];
buildTools = [ happy ];
extraLibraries = [ boehmgc gmp ];

5
pkgs/development/compilers/jdk/dlj-bundle-builder.sh
View File

@@ -37,6 +37,11 @@ else
jrePath=$out/jre
fi
if test -n "$jce"; then
unzip $jce
cp -v jce/*.jar $jrePath/lib/security
fi
rpath=$rpath${rpath:+:}$jrePath/lib/$architecture/jli
# set all the dynamic linkers

12
pkgs/development/compilers/jdk/jdk6-linux.nix
View File

@@ -6,6 +6,7 @@
, xlibs ? null
, installjdk ? true
, pluginSupport ? true
, installjce ? false
}:
assert stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux";
@@ -24,6 +25,15 @@ let
else
abort "jdk requires i686-linux or x86_64 linux";
jce =
if installjce then
requireFile {
name = "jce_policy-6.zip";
url = http://www.oracle.com/technetwork/java/javase/downloads/jce-6-download-429243.html;
sha256 = "0qljzfxbikm8br5k7rkamibp1vkyjrf6blbxpx6hn4k46f62bhnh";
}
else
null;
in
stdenv.mkDerivation {
@@ -65,7 +75,7 @@ stdenv.mkDerivation {
[stdenv.gcc.libc] ++
(if swingSupport then [xlibs.libX11 xlibs.libXext xlibs.libXtst xlibs.libXi xlibs.libXp xlibs.libXt] else []);
inherit swingSupport pluginSupport architecture;
inherit swingSupport pluginSupport architecture jce;
inherit (xlibs) libX11;
mozillaPlugin = if installjdk then "/jre/lib/${architecture}/plugins" else "/lib/${architecture}/plugins";

8
pkgs/development/compilers/julia/default.nix
View File

@@ -8,7 +8,7 @@ let
in
stdenv.mkDerivation rec {
pname = "julia";
date = "20130611";
date = "20131013";
name = "${pname}-git-${date}";
grisu_ver = "1.1.1";
@@ -65,8 +65,8 @@ stdenv.mkDerivation rec {
src = fetchgit {
url = "git://github.com/JuliaLang/julia.git";
rev = "60cc4e44bf415dcda90f2bbe22300f842fe44098";
sha256 = "018s0zyvdkxjldbvcdv40q3v2gcjznyyql5pv3zhhy1iq11jddfz";
rev = "76d2b87a45fff637473c4c342c9f5f9387675fda";
sha256 = "079g44r27lv0wsfbg84ihrmgzl73djjjr41xjiaqdph55zqfbn4f";
};
buildInputs = [ gfortran perl m4 gmp pcre llvm readline zlib
@@ -131,7 +131,7 @@ stdenv.mkDerivation rec {
'';
meta = {
description = "High-level performance-oriented dynamical language for technical computing.";
description = "High-level performance-oriented dynamical language for technical computing";
homepage = "http://julialang.org/";
license = stdenv.lib.licenses.mit;
maintainers = [ stdenv.lib.maintainers.raskin ];

2
pkgs/development/compilers/mlton/default.nix
View File

@@ -77,7 +77,7 @@ stdenv.mkDerivation rec {
'';
meta = {
description = "MLton is an open-source, whole-program, optimizing Standard ML compiler.";
description = "Open-source, whole-program, optimizing Standard ML compiler";
longDescription = ''
MLton is an open source, whole-program optimizing compiler for the Standard ML programming language.
MLton aims to produce fast executables, and to encourage rapid prototyping and modular programming

63
pkgs/development/compilers/ocaml/4.01.0.nix Normal file
View File

@@ -0,0 +1,63 @@
{ stdenv, fetchurl, ncurses, x11 }:
let
useX11 = !stdenv.isArm && !stdenv.isMips;
useNativeCompilers = !stdenv.isMips;
inherit (stdenv.lib) optionals optionalString;
in
stdenv.mkDerivation rec {
name = "ocaml-4.01.0";
src = fetchurl {
url = "http://caml.inria.fr/pub/distrib/ocaml-4.01/${name}.tar.bz2";
sha256 = "b1ca708994180236917ae79e17606da5bd334ca6acd6873a550027e1c0ec874a";
};
prefixKey = "-prefix ";
configureFlags = ["-no-tk"] ++ optionals useX11 [ "-x11lib" x11 ];
buildFlags = "world" + optionalString useNativeCompilers " bootstrap world.opt";
buildInputs = [ncurses] ++ optionals useX11 [ x11 ];
installTargets = "install" + optionalString useNativeCompilers " installopt";
preConfigure = ''
CAT=$(type -tp cat)
sed -e "s@/bin/cat@$CAT@" -i config/auto-aux/sharpbang
'';
postBuild = ''
mkdir -p $out/include
ln -sv $out/lib/ocaml/caml $out/include/caml
'';
passthru = {
nativeCompilers = useNativeCompilers;
};
meta = {
homepage = http://caml.inria.fr/ocaml;
licenses = [ "QPL" /* compiler */ "LGPLv2" /* library */ ];
description = "OCaml, the most popular variant of the Caml language";
longDescription =
''
OCaml is the most popular variant of the Caml language. From a
language standpoint, it extends the core Caml language with a
fully-fledged object-oriented layer, as well as a powerful module
system, all connected by a sound, polymorphic type system featuring
type inference.
The OCaml system is an industrial-strength implementation of this
language, featuring a high-performance native-code compiler (ocamlopt)
for 9 processor architectures (IA32, PowerPC, AMD64, Alpha, Sparc,
Mips, IA64, HPPA, StrongArm), as well as a bytecode compiler (ocamlc)
and an interactive read-eval-print loop (ocaml) for quick development
and portability. The OCaml distribution includes a comprehensive
standard library, a replay debugger (ocamldebug), lexer (ocamllex) and
parser (ocamlyacc) generators, a pre-processor pretty-printer (camlp4)
and a documentation generator (ocamldoc).
'';
platforms = stdenv.lib.platforms.linux ++ stdenv.lib.platforms.darwin;
};
}

8
pkgs/development/compilers/sbcl/default.nix
View File

@@ -4,11 +4,11 @@ let
s= # Generated upstream information
rec {
baseName="sbcl";
version="1.1.8";
version="1.1.12";
name="${baseName}-${version}";
hash="1fmcpsi2bddfpz3impm9i62y9p15r3mc4xgm1dg0k77l33859jip";
url="mirror://sourceforge/project/sbcl/sbcl/1.1.8/sbcl-1.1.8-source.tar.bz2";
sha256="1fmcpsi2bddfpz3impm9i62y9p15r3mc4xgm1dg0k77l33859jip";
hash="0mvl6lpi44yv6jv3xhyyzvf9g7bdlj691iz3ydpn66v0vg5i554c";
url="mirror://sourceforge/project/sbcl/sbcl/1.1.12/sbcl-1.1.12-source.tar.bz2";
sha256="0mvl6lpi44yv6jv3xhyyzvf9g7bdlj691iz3ydpn66v0vg5i554c";
};
buildInputs = with a; [
clisp makeWrapper

66
pkgs/development/compilers/smlnj/default.nix Normal file
View File

@@ -0,0 +1,66 @@
{ stdenv, fetchurl }:
let
version = "110.76";
baseurl = "http://smlnj.cs.uchicago.edu/dist/working/${version}";
sources = map fetchurl [
{ url = "${baseurl}/config.tgz"; sha256 = "0mx5gib1jq5hl3j6gvkkfh60x2hx146xiisclaz4jgy452ywikj1"; }
{ url = "${baseurl}/cm.tgz"; sha256 = "14y1pqqw5p5va3rvpk2jddx2gcm37z5hwp5zdm43z02afscq37jk"; }
{ url = "${baseurl}/compiler.tgz"; sha256 = "10gn7cwqzbnh4k3l6brb9hp59k9vz2m9fcaarv2fw1gilfw5a9rj"; }
{ url = "${baseurl}/runtime.tgz"; sha256 = "0zqajizayzrlrxm47q492mqgfxya7rwqrq4faafai8qfwga6q27n"; }
{ url = "${baseurl}/system.tgz"; sha256 = "0dys0f0cdgnivk1niam9g736c3mzrjf9r29051g0579an8yi8slg"; }
{ url = "${baseurl}/MLRISC.tgz"; sha256 = "00n1zk65cwf2kf669mn09lp0ya6bfap1czhyq0nfza409vm4v54x"; }
{ url = "${baseurl}/smlnj-lib.tgz"; sha256 = "1mx1vjxbpfgcq6fkmh2qirjfqzn3wcnjf4a9ijr7k2bwgnh99sc1"; }
{ url = "${baseurl}/ckit.tgz"; sha256 = "1fqdxs2cgzffj0i9rmzv1aljwnhx98hyvj3c2kivw3ligxp4wly4"; }
{ url = "${baseurl}/nlffi.tgz"; sha256 = "08dmvs95xmbas3hx7n0csxxl0d0bmhxg7gav1ay02gy9n8iw3g87"; }
{ url = "${baseurl}/cml.tgz"; sha256 = "1qc1hs2k2xmn03ldyz2zf0pzbryd1n4bwix226ch8z9pnfimglyb"; }
{ url = "${baseurl}/eXene.tgz"; sha256 = "01z69rgmshh694wkcwrzi72z5d5glpijj7mqxb17yz106xyzmgim"; }
{ url = "${baseurl}/ml-lpt.tgz"; sha256 = "13gw4197ivzvd6qcbg5pzclhv1f2jy2c433halh021d60qjv4w4r"; }
{ url = "${baseurl}/ml-lex.tgz"; sha256 = "0sqa533zca1l7p79qhkb7lspvhk4k2r3839745sci32fzwy1804x"; }
{ url = "${baseurl}/ml-yacc.tgz"; sha256 = "1kzi0dpybd9hkklk460mgbwfkixjhav225kkmwnk3jxby3zgflci"; }
{ url = "${baseurl}/ml-burg.tgz"; sha256 = "0kjrba8l0v6jn3g6gv9dvrklpvxx9x57b7czwnrrd33pi28sv7fm"; }
{ url = "${baseurl}/pgraph.tgz"; sha256 = "174n22m7zibgk68033qql86kyk6mxjni4j0kcadafs0g2xmh6i6z"; }
{ url = "${baseurl}/trace-debug-profile.tgz"; sha256 = "1pq4wwx5ad7zx1306ka06lqwnjv446zz6ndpq6s9ak6ha79f2s9p"; }
{ url = "${baseurl}/heap2asm.tgz"; sha256 = "0p91fzwkfr7hng7c026gy5ggl5l9isxpm007iq6ivpjrfjy547wc"; }
{ url = "${baseurl}/smlnj-c.tgz"; sha256 = "0vra4gi91w0cjsw3rm162hgz5xsqbr7yds44q7zhs27kccsirpqc"; }
{ url = "${baseurl}/boot.x86-unix.tgz"; sha256 = "0qcvdhlvpr02c1ssk4jz6175lb9pkdg7zrfscqz6f7crnsgmc5nx"; }
];
in stdenv.mkDerivation {
name = "smlnj-${version}";
inherit sources;
patchPhase = ''
sed -i '/PATH=/d' config/_arch-n-opsys base/runtime/config/gen-posix-names.sh
echo SRCARCHIVEURL="file:/$TMP" > config/srcarchiveurl
'';
unpackPhase = ''
for s in $sources; do
b=$(basename $s)
cp $s ''${b#*-}
done
unpackFile config.tgz
mkdir base
./config/unpack $TMP runtime
'';
buildPhase = ''
./config/install.sh
'';
installPhase = ''
mkdir -pv $out
cp -rv bin lib $out
for i in $out/bin/*; do
sed -i "2iSMLNJ_HOME=$out/" $i
done
'';
meta = {
description = "Standard ML of New Jersey, a compiler";
homepage = http://smlnj.org;
license = stdenv.lib.licenses.bsd3;
};
}

2
pkgs/development/compilers/uhc/default.nix
View File

@@ -4,7 +4,7 @@
# this check won't be needed anymore after ghc-wrapper is fixed
# to show ghc-builtin packages in "ghc-pkg list" output.
let binaryIsBuiltIn = builtins.compareVersions "7.2.1" ghc.ghcVersion != 1;
let binaryIsBuiltIn = builtins.compareVersions "7.2.1" ghc.version != 1;
in stdenv.mkDerivation {
name = "uhc-svn-git20120502";

2
pkgs/development/compilers/urweb/default.nix
View File

@@ -32,7 +32,7 @@ stdenv.mkDerivation rec {
dontDisableStatic = true;
meta = {
description = "Ur/Web supports construction of dynamic web applications backed by SQL databases.";
description = "Construct dynamic web applications backed by SQL databases";
longDescription = ''
Ur is a programming language in the tradition of ML and Haskell, but
featuring a significantly richer type system. Ur is functional, pure,

2
pkgs/development/compilers/yap/default.nix
View File

@@ -11,6 +11,8 @@ stdenv.mkDerivation rec {
buildInputs = [ readline gmp zlib ];
configureFlags = "--enable-tabling=yes";
meta = {
homepage = "http://www.dcc.fc.up.pt/~vsc/Yap/";
description = "Yap Prolog System is a ISO-compatible high-performance Prolog compiler";