2006-02-08 20:37:45 +03:00
|
|
|
/* This file composes the Nix Packages collection. That is, it
|
|
|
|
imports the functions that build the various packages, and calls
|
|
|
|
them with appropriate arguments. The result is a set of all the
|
|
|
|
packages in the Nix Packages collection for some particular
|
2010-07-28 20:09:13 +04:00
|
|
|
platform. */
|
2008-06-19 02:48:34 +04:00
|
|
|
|
2006-02-08 20:37:45 +03:00
|
|
|
|
2006-08-23 19:58:54 +04:00
|
|
|
{ # The system (e.g., `i686-linux') for which to build the packages.
|
2009-04-14 17:59:45 +04:00
|
|
|
system ? builtins.currentSystem
|
2003-11-02 20:42:19 +03:00
|
|
|
|
2006-08-23 19:58:54 +04:00
|
|
|
# Usually, the system type uniquely determines the stdenv and thus
|
|
|
|
# how to build the packages. But on some platforms we have
|
|
|
|
# different stdenvs, leading to different ways to build the
|
|
|
|
# packages. For instance, on Windows we support both Cygwin and
|
|
|
|
# Mingw builds. In both cases, `system' is `i686-cygwin'. The
|
|
|
|
# attribute `stdenvType' is used to select the specific kind of
|
|
|
|
# stdenv to use, e.g., `i686-mingw'.
|
|
|
|
, stdenvType ? system
|
|
|
|
|
2006-02-08 20:37:45 +03:00
|
|
|
, # The standard environment to use. Only used for bootstrapping. If
|
|
|
|
# null, the default standard environment is used.
|
|
|
|
bootStdenv ? null
|
|
|
|
|
|
|
|
# More flags for the bootstrapping of stdenv.
|
|
|
|
, noSysDirs ? true
|
2004-09-18 21:23:18 +04:00
|
|
|
, gccWithCC ? true
|
|
|
|
, gccWithProfiling ? true
|
2004-03-11 20:26:14 +03:00
|
|
|
|
2009-08-26 17:51:37 +04:00
|
|
|
, # Allow a configuration attribute set to be passed in as an
|
|
|
|
# argument. Otherwise, it's read from $NIXPKGS_CONFIG or
|
|
|
|
# ~/.nixpkgs/config.nix.
|
|
|
|
config ? null
|
2010-01-26 21:10:59 +03:00
|
|
|
|
I made the whole nixpkgs dependencies available to the cross compiler, no
needing to keep a new tree of expressions apart for the expressions to get
cross-compiled.
I changed the whole way of using cross compilation with nixpkgs, which before
was done through a simple adapter.
Now the adapter became complex, and I've tried to avoid the most obvious
recursivities. For example, the fetchurl expression should
never be cross-compiled, as the gmp, mpfr, and some others, like
some ncurses, perl, ... I made overrided copies of those necessary as
perlNoCross, ncursesNoCross, as stdenvNoCross, keeping in mind that
the stdenv (capable of cross compilation) is built upon stdenvNoCross using
an adapter.
So, to cross compile, instead of building using "nixpkgs/default.nix",
you should build with your
own "myarchiteture.nix", which should have contents like these, for example:
import /etc/nixos/nixpkgs/default.nix
{
crossSystem = {
config = "armv5tel-unknown-linux-gnueabi";
bigEndian = false;
arch = "arm";
float = "soft";
};
}
svn path=/nixpkgs/branches/stdenv-updates/; revision=18398
2009-11-18 01:58:48 +03:00
|
|
|
, crossSystem ? null
|
2010-09-04 01:34:49 +04:00
|
|
|
, platform ? null
|
2006-02-08 20:37:45 +03:00
|
|
|
}:
|
2003-11-03 13:22:00 +03:00
|
|
|
|
2003-11-25 21:02:05 +03:00
|
|
|
|
2010-09-04 01:34:49 +04:00
|
|
|
let config_ = config; platform_ = platform; in # rename the function arguments
|
2009-08-26 17:51:37 +04:00
|
|
|
|
2008-08-26 19:35:00 +04:00
|
|
|
let
|
|
|
|
|
2010-03-25 22:40:19 +03:00
|
|
|
lib = import ../lib;
|
2008-08-26 19:35:00 +04:00
|
|
|
|
|
|
|
# The contents of the configuration file found at $NIXPKGS_CONFIG or
|
|
|
|
# $HOME/.nixpkgs/config.nix.
|
2009-09-21 19:55:18 +04:00
|
|
|
# for NIXOS (nixos-rebuild): use nixpkgs.config option
|
2008-08-26 19:35:00 +04:00
|
|
|
config =
|
2009-08-26 17:51:37 +04:00
|
|
|
let
|
2008-08-26 19:35:00 +04:00
|
|
|
toPath = builtins.toPath;
|
|
|
|
getEnv = x: if builtins ? getEnv then builtins.getEnv x else "";
|
|
|
|
pathExists = name:
|
|
|
|
builtins ? pathExists && builtins.pathExists (toPath name);
|
|
|
|
|
|
|
|
configFile = getEnv "NIXPKGS_CONFIG";
|
|
|
|
homeDir = getEnv "HOME";
|
|
|
|
configFile2 = homeDir + "/.nixpkgs/config.nix";
|
|
|
|
|
2009-03-25 16:29:47 +03:00
|
|
|
configExpr =
|
2009-08-26 17:51:37 +04:00
|
|
|
if config_ != null then config_
|
|
|
|
else if configFile != "" && pathExists configFile then import (toPath configFile)
|
|
|
|
else if homeDir != "" && pathExists configFile2 then import (toPath configFile2)
|
2008-08-26 19:35:00 +04:00
|
|
|
else {};
|
2009-03-25 16:29:47 +03:00
|
|
|
|
2009-08-26 17:51:37 +04:00
|
|
|
in
|
2009-03-25 16:29:47 +03:00
|
|
|
# allow both:
|
|
|
|
# { /* the config */ } and
|
2010-09-03 14:46:18 +04:00
|
|
|
# { pkgs, ... } : { /* the config */ }
|
2009-08-26 17:51:37 +04:00
|
|
|
if builtins.isFunction configExpr
|
2010-09-03 14:46:18 +04:00
|
|
|
then configExpr { inherit pkgs; }
|
2009-03-25 16:29:47 +03:00
|
|
|
else configExpr;
|
2008-08-26 19:35:00 +04:00
|
|
|
|
2010-09-04 01:34:49 +04:00
|
|
|
# Allow setting the platform in the config file. Otherwise, let's use a reasonable default (pc)
|
2011-02-24 14:25:16 +03:00
|
|
|
platform = if platform_ != null then platform_
|
2010-09-04 01:34:49 +04:00
|
|
|
else getConfig [ "platform" ] (import ./platforms.nix).pc;
|
|
|
|
|
2008-08-26 19:35:00 +04:00
|
|
|
# Return an attribute from the Nixpkgs configuration file, or
|
|
|
|
# a default value if the attribute doesn't exist.
|
2009-05-24 14:57:41 +04:00
|
|
|
getConfig = attrPath: default: lib.attrByPath attrPath default config;
|
2008-08-26 19:35:00 +04:00
|
|
|
|
|
|
|
|
2009-11-19 19:07:47 +03:00
|
|
|
# Helper functions that are exported through `pkgs'.
|
2009-11-27 20:40:56 +03:00
|
|
|
helperFunctions =
|
2010-01-03 20:56:55 +03:00
|
|
|
stdenvAdapters //
|
2009-11-19 19:07:47 +03:00
|
|
|
(import ../build-support/trivial-builders.nix { inherit (pkgs) stdenv; inherit (pkgs.xorg) lndir; });
|
|
|
|
|
2010-01-03 20:56:55 +03:00
|
|
|
stdenvAdapters =
|
|
|
|
import ../stdenv/adapters.nix { inherit (pkgs) dietlibc fetchurl runCommand; };
|
|
|
|
|
2009-11-19 19:07:47 +03:00
|
|
|
|
2008-08-26 19:35:00 +04:00
|
|
|
# Allow packages to be overriden globally via the `packageOverrides'
|
|
|
|
# configuration option, which must be a function that takes `pkgs'
|
|
|
|
# as an argument and returns a set of new or overriden packages.
|
2010-09-03 14:46:18 +04:00
|
|
|
# The `packageOverrides' function is called with the *original*
|
2008-08-26 20:50:33 +04:00
|
|
|
# (un-overriden) set of packages, allowing packageOverrides
|
|
|
|
# attributes to refer to the original attributes (e.g. "foo =
|
|
|
|
# ... pkgs.foo ...").
|
2010-09-03 14:46:18 +04:00
|
|
|
pkgs = applyGlobalOverrides (getConfig ["packageOverrides"] (pkgs: {}));
|
|
|
|
|
|
|
|
|
|
|
|
# Return the complete set of packages, after applying the overrides
|
2011-07-05 18:38:31 +04:00
|
|
|
# returned by the `overrider' function (see above). Warning: this
|
|
|
|
# function is very expensive!
|
2010-09-03 14:46:18 +04:00
|
|
|
applyGlobalOverrides = overrider:
|
|
|
|
let
|
|
|
|
# Call the overrider function. We don't want stdenv overrides
|
|
|
|
# in the case of cross-building, or otherwise the basic
|
|
|
|
# overrided packages will not be built with the crossStdenv
|
|
|
|
# adapter.
|
|
|
|
overrides = overrider pkgsOrig //
|
2011-12-14 18:31:56 +04:00
|
|
|
(lib.optionalAttrs (pkgsOrig.stdenv ? overrides && crossSystem == null) (pkgsOrig.stdenv.overrides pkgsOrig));
|
2010-09-03 14:46:18 +04:00
|
|
|
|
|
|
|
# The un-overriden packages, passed to `overrider'.
|
2010-09-17 18:47:02 +04:00
|
|
|
pkgsOrig = pkgsFun pkgs {};
|
2008-08-26 20:50:33 +04:00
|
|
|
|
2010-09-03 14:46:18 +04:00
|
|
|
# The overriden, final packages.
|
2010-09-17 18:47:02 +04:00
|
|
|
pkgs = pkgsFun pkgs overrides;
|
2010-09-03 14:46:18 +04:00
|
|
|
in pkgs;
|
2008-08-26 20:50:33 +04:00
|
|
|
|
2010-09-03 14:46:18 +04:00
|
|
|
|
|
|
|
# The package compositions. Yes, this isn't properly indented.
|
|
|
|
pkgsFun = pkgs: __overrides:
|
|
|
|
with helperFunctions;
|
|
|
|
let defaultScope = pkgs // pkgs.xorg; in
|
|
|
|
helperFunctions // rec {
|
|
|
|
|
|
|
|
# `__overrides' is a magic attribute that causes the attributes in
|
|
|
|
# its value to be added to the surrounding `rec'. We'll remove this
|
|
|
|
# eventually.
|
|
|
|
inherit __overrides;
|
2008-10-09 14:10:49 +04:00
|
|
|
|
2008-08-26 19:35:00 +04:00
|
|
|
|
2010-08-02 17:57:57 +04:00
|
|
|
# We use `callPackage' to be able to omit function arguments that
|
|
|
|
# can be obtained from `pkgs' or `pkgs.xorg' (i.e. `defaultScope').
|
|
|
|
# Use `newScope' for sets of packages in `pkgs' (see e.g. `gtkLibs'
|
|
|
|
# below).
|
|
|
|
callPackage = newScope {};
|
|
|
|
|
|
|
|
newScope = extra: lib.callPackageWith (defaultScope // extra);
|
2010-08-03 01:40:34 +04:00
|
|
|
|
2010-08-06 16:47:20 +04:00
|
|
|
|
2010-03-25 22:40:19 +03:00
|
|
|
# Override system. This is useful to build i686 packages on x86_64-linux.
|
2010-01-04 10:44:30 +03:00
|
|
|
forceSystem = system: (import ./all-packages.nix) {
|
|
|
|
inherit system;
|
|
|
|
inherit bootStdenv noSysDirs gccWithCC gccWithProfiling config;
|
|
|
|
};
|
|
|
|
|
2010-09-17 18:47:02 +04:00
|
|
|
|
2010-03-25 22:40:19 +03:00
|
|
|
# Used by wine, firefox with debugging version of Flash, ...
|
2010-01-04 10:44:30 +03:00
|
|
|
pkgsi686Linux = forceSystem "i686-linux";
|
2008-08-26 19:35:00 +04:00
|
|
|
|
2010-08-11 17:25:30 +04:00
|
|
|
callPackage_i686 = lib.callPackageWith (pkgsi686Linux // pkgsi686Linux.xorg);
|
|
|
|
|
2008-08-26 19:35:00 +04:00
|
|
|
|
|
|
|
# For convenience, allow callers to get the path to Nixpkgs.
|
2009-06-09 02:43:27 +04:00
|
|
|
path = ../..;
|
2003-11-25 21:02:05 +03:00
|
|
|
|
2008-10-09 14:10:49 +04:00
|
|
|
|
2004-03-28 00:59:31 +03:00
|
|
|
### Symbolic names.
|
|
|
|
|
2006-09-15 19:28:53 +04:00
|
|
|
|
|
|
|
x11 = xlibsWrapper;
|
|
|
|
|
2005-11-12 20:05:51 +03:00
|
|
|
# `xlibs' is the set of X library components. This used to be the
|
|
|
|
# old modular X libraries project (called `xlibs') but now it's just
|
|
|
|
# the set of packages in the modular X.org tree (which also includes
|
|
|
|
# non-library components like the server, drivers, fonts, etc.).
|
2006-07-17 16:46:39 +04:00
|
|
|
xlibs = xorg // {xlibs = xlibsWrapper;};
|
2005-11-12 20:05:51 +03:00
|
|
|
|
2006-02-08 20:37:45 +03:00
|
|
|
|
2006-02-09 20:04:18 +03:00
|
|
|
### Helper functions.
|
|
|
|
|
2006-03-23 19:47:34 +03:00
|
|
|
|
2010-01-03 20:56:55 +03:00
|
|
|
inherit lib config getConfig stdenvAdapters;
|
2008-10-09 14:10:49 +04:00
|
|
|
|
2010-07-22 12:59:46 +04:00
|
|
|
inherit (lib) lowPrio hiPrio appendToName makeOverridable;
|
2006-10-18 16:50:04 +04:00
|
|
|
|
2006-09-15 19:28:53 +04:00
|
|
|
# Applying this to an attribute set will cause nix-env to look
|
|
|
|
# inside the set for derivations.
|
2012-01-12 20:59:58 +04:00
|
|
|
recurseIntoAttrs = attrs: attrs // { recurseForDerivations = true; };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
2010-07-29 12:21:21 +04:00
|
|
|
builderDefs = lib.composedArgsAndFun (import ../build-support/builder-defs/builder-defs.nix) {
|
2009-09-23 00:16:38 +04:00
|
|
|
inherit stringsWithDeps lib stdenv writeScript
|
2009-07-07 14:04:32 +04:00
|
|
|
fetchurl fetchmtn fetchgit;
|
2008-03-17 12:41:28 +03:00
|
|
|
};
|
|
|
|
|
2008-08-19 09:54:09 +04:00
|
|
|
builderDefsPackage = builderDefs.builderDefsPackage builderDefs;
|
2008-03-20 18:40:26 +03:00
|
|
|
|
2009-05-25 22:22:19 +04:00
|
|
|
stringsWithDeps = lib.stringsWithDeps;
|
2007-10-29 13:52:04 +03:00
|
|
|
|
2009-09-23 00:16:38 +04:00
|
|
|
|
2006-02-08 20:37:45 +03:00
|
|
|
### STANDARD ENVIRONMENT
|
|
|
|
|
|
|
|
|
2008-06-18 19:09:13 +04:00
|
|
|
allStdenvs = import ../stdenv {
|
2010-08-22 01:08:57 +04:00
|
|
|
inherit system stdenvType platform;
|
2009-08-26 17:51:37 +04:00
|
|
|
allPackages = args: import ./all-packages.nix ({ inherit config; } // args);
|
2008-06-18 19:09:13 +04:00
|
|
|
};
|
|
|
|
|
Simplified much more the expressions for cross building and multiplatform.
I introduce the new nixpkgs parameter "platform", defaulting to "pc",
which was before defined as an attribute of nixpkgs.
I made the crossSystem nixpkgs attribute set parameter contain its own 'platform'.
This allows cross-building a kernel for a given crossSystem.platform in a non-PC
platform.
The actual native platform can be taken from stdenv.platform, and this way we also
avoid the constant passing of 'platform' to packages for platform-dependant builds
(kernel, initrd, ...).
I will update nixos accordingly to these changes, for non-PC platforms to work.
I think we are gaining on flexibility and clearness. I could cross build succesfully
an ultrasparc kernel and a mipsel kernel on PC. But since this change, I should be able
to do this also in non-PC.
Before this change, there was no possibility of distinguishing the "target platform" or
the "native build platform" when cross building, being the single "platform" attribute
always interpreted as target platform.
The platform is a quite relevant attribute set, as it determines the linuxHeaders used
(in the case, by now the only one supported, of linux targets).
The platform attributes are quite linux centric still. Let's hope for more generality to come.
svn path=/nixpkgs/trunk/; revision=20273
2010-02-27 20:35:47 +03:00
|
|
|
defaultStdenv = allStdenvs.stdenv // { inherit platform; };
|
2006-02-08 20:37:45 +03:00
|
|
|
|
2010-03-07 02:36:55 +03:00
|
|
|
stdenvCross = makeStdenvCross defaultStdenv crossSystem binutilsCross
|
|
|
|
gccCrossStageFinal;
|
- Removed all *NoCross expressions I dupilcated in nixpkgs, while maintaining
the cross compilation functionality.
- I renamed some expected stdenv.mkDerivation parameter attributes so we can
keep this branch properly updated from trunk. We agreed with Nicolas Pierron
doing a massive renaming, so all current buildInputs become hostInputs (input
as build for the host machine, in autotools terminology) , and
then buildInputs would mean "input as for the build machine".
By now, the specific "input as for the build machine" is specified through
buildNativeInputs. We should fix this in the merge to trunk.
- I made the generic stdenv understand the buildNativeInputs, otherwise if
we start changing nixpkgs expressions so they distinguish the current
buildInputs into buildInputs and buildNativeInputs, we could break even more
nixpkgs for other platforms.
- I changed the default result of mkDerivation so it becomes the derivation for
to be run in the build machine. This allows, without any special rewriting,
"fetchurl" derivations to be always results for the build machine to use
them.
- The change above implies that, for anyone wanting to cross-compile, has to
build the hostDrv of the wanted derivation. For example, after this commit,
the usual test of "nix-build -A bison.hostDrv arm.nix" works. I described
the contents of this arm.nix in r18398.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18471
2009-11-19 22:03:34 +03:00
|
|
|
|
2010-01-21 18:39:11 +03:00
|
|
|
stdenv =
|
2010-08-02 01:21:26 +04:00
|
|
|
if bootStdenv != null then (bootStdenv // {inherit platform;}) else
|
2012-01-21 04:26:50 +04:00
|
|
|
if crossSystem != null then
|
2010-02-08 18:28:05 +03:00
|
|
|
stdenvCross
|
2012-01-21 04:26:50 +04:00
|
|
|
else
|
|
|
|
let
|
|
|
|
changer = getConfig ["replaceStdenv"] null;
|
|
|
|
in if changer != null then
|
|
|
|
changer {
|
|
|
|
# We import again all-packages to avoid recursivities.
|
|
|
|
pkgs = import ./all-packages.nix {
|
|
|
|
# We remove packageOverrides to avoid recursivities
|
|
|
|
config = removeAttrs config [ "replaceStdenv" ];
|
|
|
|
};
|
|
|
|
}
|
2010-02-08 18:28:05 +03:00
|
|
|
else
|
|
|
|
defaultStdenv;
|
I made the whole nixpkgs dependencies available to the cross compiler, no
needing to keep a new tree of expressions apart for the expressions to get
cross-compiled.
I changed the whole way of using cross compilation with nixpkgs, which before
was done through a simple adapter.
Now the adapter became complex, and I've tried to avoid the most obvious
recursivities. For example, the fetchurl expression should
never be cross-compiled, as the gmp, mpfr, and some others, like
some ncurses, perl, ... I made overrided copies of those necessary as
perlNoCross, ncursesNoCross, as stdenvNoCross, keeping in mind that
the stdenv (capable of cross compilation) is built upon stdenvNoCross using
an adapter.
So, to cross compile, instead of building using "nixpkgs/default.nix",
you should build with your
own "myarchiteture.nix", which should have contents like these, for example:
import /etc/nixos/nixpkgs/default.nix
{
crossSystem = {
config = "armv5tel-unknown-linux-gnueabi";
bigEndian = false;
arch = "arm";
float = "soft";
};
}
svn path=/nixpkgs/branches/stdenv-updates/; revision=18398
2009-11-18 01:58:48 +03:00
|
|
|
|
2010-02-09 10:43:36 +03:00
|
|
|
forceBuildDrv = drv : if (crossSystem == null) then drv else
|
|
|
|
(drv // { hostDrv = drv.buildDrv; });
|
Big fixes in the cross build:
- Before this changes, cflags and ldflags for the native and the cross compiler
got mixed. Not all the gcc-wrapper/gcc-cross-wrapper variables are
independant now, but enough, I think.
- Fixed the generic stdenv expression, which did a big mess on buildInputs and
buildNativeInputs. Now it distinguishes when there is a stdenvCross or not.
Maybe we should have a single stdenv and forget about the stdenvCross
adapter - this could end in a stdenv a bit complex, but simpler than the
generic stdenv + adapter.
- Added basic support in pkgconfig for cross-builds: a single PKG_CONFIG_PATH
now works for both the cross and the native compilers, but I think this
should work well for most cases I can think of.
- I tried to fix the guile expression to cross-biuld; guile is built, but not
its manual, so the derivation still fails. Guile requires patching to
cross-build, as far as I understnad.
- Made the glibcCross build to be done through the usage of a
gcc-cross-wrapper over the gcc-cross-stage-static, instead of using it
directly.
- Trying to make physfs (a neverball dependency) cross build.
- Updated the gcc expression to support building a cross compiler without getting
derivation variables mixed with those of the stdenvCross.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18534
2009-11-22 22:51:45 +03:00
|
|
|
|
2008-06-29 20:13:02 +04:00
|
|
|
# A stdenv capable of building 32-bit binaries. On x86_64-linux,
|
|
|
|
# it uses GCC compiled with multilib support; on i686-linux, it's
|
|
|
|
# just the plain stdenv.
|
|
|
|
stdenv_32bit =
|
|
|
|
if system == "x86_64-linux" then
|
2009-04-15 17:28:17 +04:00
|
|
|
overrideGCC stdenv gcc43_multi
|
2008-06-29 20:13:02 +04:00
|
|
|
else
|
|
|
|
stdenv;
|
|
|
|
|
2010-07-29 23:56:16 +04:00
|
|
|
|
2006-09-15 19:28:53 +04:00
|
|
|
### BUILD SUPPORT
|
2003-11-02 20:42:19 +03:00
|
|
|
|
2009-08-24 02:10:08 +04:00
|
|
|
attrSetToDir = arg : import ../build-support/upstream-updater/attrset-to-dir.nix {
|
|
|
|
inherit writeTextFile stdenv lib;
|
|
|
|
theAttrSet = arg;
|
|
|
|
};
|
2003-11-25 21:02:05 +03:00
|
|
|
|
2006-11-28 19:46:12 +03:00
|
|
|
buildEnv = import ../build-support/buildenv {
|
2012-02-21 18:13:16 +04:00
|
|
|
inherit (pkgs) runCommand perl;
|
2006-11-28 19:46:12 +03:00
|
|
|
};
|
2008-06-19 02:48:34 +04:00
|
|
|
|
2010-06-15 15:16:35 +04:00
|
|
|
dotnetenv = import ../build-support/dotnetenv {
|
|
|
|
inherit stdenv;
|
2011-10-04 17:28:32 +04:00
|
|
|
dotnetfx = dotnetfx40;
|
2010-06-15 15:16:35 +04:00
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
vsenv = callPackage ../build-support/vsenv {
|
2010-06-15 15:32:19 +04:00
|
|
|
vs = vs90wrapper;
|
2008-03-02 21:41:32 +03:00
|
|
|
};
|
|
|
|
|
2008-09-26 12:57:51 +04:00
|
|
|
fetchbzr = import ../build-support/fetchbzr {
|
|
|
|
inherit stdenv bazaar;
|
|
|
|
};
|
|
|
|
|
2006-10-18 14:32:45 +04:00
|
|
|
fetchcvs = import ../build-support/fetchcvs {
|
2008-02-29 01:36:37 +03:00
|
|
|
inherit stdenv cvs;
|
2006-05-11 16:36:16 +04:00
|
|
|
};
|
|
|
|
|
2006-10-18 14:32:45 +04:00
|
|
|
fetchdarcs = import ../build-support/fetchdarcs {
|
2006-01-30 14:18:38 +03:00
|
|
|
inherit stdenv darcs nix;
|
|
|
|
};
|
|
|
|
|
2009-06-24 16:48:01 +04:00
|
|
|
fetchgit = import ../build-support/fetchgit {
|
2011-08-28 20:03:14 +04:00
|
|
|
inherit stdenv git cacert;
|
2009-06-24 16:48:01 +04:00
|
|
|
};
|
|
|
|
|
2011-01-03 02:23:59 +03:00
|
|
|
fetchgitrevision = import ../build-support/fetchgitrevision runCommand git;
|
|
|
|
|
2011-08-23 21:45:40 +04:00
|
|
|
fetchmtn = callPackage ../build-support/fetchmtn (getConfig ["fetchmtn"] {});
|
2009-07-07 14:04:32 +04:00
|
|
|
|
2006-10-18 14:32:45 +04:00
|
|
|
fetchsvn = import ../build-support/fetchsvn {
|
2008-02-29 13:30:29 +03:00
|
|
|
inherit stdenv subversion openssh;
|
2006-09-15 19:28:53 +04:00
|
|
|
sshSupport = true;
|
|
|
|
};
|
|
|
|
|
2011-01-03 02:23:59 +03:00
|
|
|
fetchsvnrevision = import ../build-support/fetchsvnrevision runCommand subversion;
|
2006-09-15 19:28:53 +04:00
|
|
|
|
2008-04-02 17:28:55 +04:00
|
|
|
fetchsvnssh = import ../build-support/fetchsvnssh {
|
|
|
|
inherit stdenv subversion openssh expect;
|
|
|
|
sshSupport = true;
|
|
|
|
};
|
|
|
|
|
2007-09-03 16:10:57 +04:00
|
|
|
fetchhg = import ../build-support/fetchhg {
|
|
|
|
inherit stdenv mercurial nix;
|
|
|
|
};
|
|
|
|
|
2010-08-06 14:34:34 +04:00
|
|
|
# `fetchurl' downloads a file from the network.
|
|
|
|
fetchurl = import ../build-support/fetchurl {
|
|
|
|
inherit curl stdenv;
|
|
|
|
};
|
2005-04-22 16:14:55 +04:00
|
|
|
|
2011-09-20 10:21:46 +04:00
|
|
|
# A wrapper around fetchurl that generates miror://gnome URLs automatically
|
|
|
|
fetchurl_gnome = callPackage ../build-support/fetchurl/gnome.nix { };
|
|
|
|
|
2008-05-27 11:49:55 +04:00
|
|
|
# fetchurlBoot is used for curl and its dependencies in order to
|
|
|
|
# prevent a cyclic dependency (curl depends on curl.tar.bz2,
|
|
|
|
# curl.tar.bz2 depends on fetchurl, fetchurl depends on curl). It
|
|
|
|
# uses the curl from the previous bootstrap phase (e.g. a statically
|
|
|
|
# linked curl in the case of stdenv-linux).
|
|
|
|
fetchurlBoot = stdenv.fetchurlBoot;
|
|
|
|
|
2008-07-23 20:04:10 +04:00
|
|
|
resolveMirrorURLs = {url}: fetchurl {
|
|
|
|
showURLs = true;
|
|
|
|
inherit url;
|
|
|
|
};
|
|
|
|
|
2009-05-10 16:03:53 +04:00
|
|
|
makeDesktopItem = import ../build-support/make-desktopitem {
|
|
|
|
inherit stdenv;
|
|
|
|
};
|
2009-05-18 17:53:01 +04:00
|
|
|
|
2012-02-02 02:09:35 +04:00
|
|
|
makeAutostartItem = import ../build-support/make-startupitem {
|
|
|
|
inherit stdenv;
|
|
|
|
inherit lib;
|
|
|
|
};
|
|
|
|
|
2008-03-17 13:40:47 +03:00
|
|
|
makeInitrd = {contents}: import ../build-support/kernel/make-initrd.nix {
|
Simplified much more the expressions for cross building and multiplatform.
I introduce the new nixpkgs parameter "platform", defaulting to "pc",
which was before defined as an attribute of nixpkgs.
I made the crossSystem nixpkgs attribute set parameter contain its own 'platform'.
This allows cross-building a kernel for a given crossSystem.platform in a non-PC
platform.
The actual native platform can be taken from stdenv.platform, and this way we also
avoid the constant passing of 'platform' to packages for platform-dependant builds
(kernel, initrd, ...).
I will update nixos accordingly to these changes, for non-PC platforms to work.
I think we are gaining on flexibility and clearness. I could cross build succesfully
an ultrasparc kernel and a mipsel kernel on PC. But since this change, I should be able
to do this also in non-PC.
Before this change, there was no possibility of distinguishing the "target platform" or
the "native build platform" when cross building, being the single "platform" attribute
always interpreted as target platform.
The platform is a quite relevant attribute set, as it determines the linuxHeaders used
(in the case, by now the only one supported, of linux targets).
The platform attributes are quite linux centric still. Let's hope for more generality to come.
svn path=/nixpkgs/trunk/; revision=20273
2010-02-27 20:35:47 +03:00
|
|
|
inherit stdenv perl cpio contents ubootChooser;
|
2008-03-17 13:40:47 +03:00
|
|
|
};
|
|
|
|
|
2011-03-29 19:19:59 +04:00
|
|
|
makeWrapper = makeSetupHook {} ../build-support/make-wrapper/make-wrapper.sh;
|
2008-01-18 13:29:58 +03:00
|
|
|
|
2008-06-19 02:48:34 +04:00
|
|
|
makeModulesClosure = {kernel, rootModules, allowMissing ? false}:
|
2008-03-24 22:40:15 +03:00
|
|
|
import ../build-support/kernel/modules-closure.nix {
|
2009-09-02 01:56:46 +04:00
|
|
|
inherit stdenv module_init_tools kernel nukeReferences
|
|
|
|
rootModules allowMissing;
|
2008-03-24 22:40:15 +03:00
|
|
|
};
|
2008-03-17 13:40:47 +03:00
|
|
|
|
2009-06-05 17:20:14 +04:00
|
|
|
pathsFromGraph = ../build-support/kernel/paths-from-graph.pl;
|
|
|
|
|
2008-10-01 19:57:22 +04:00
|
|
|
srcOnly = args: (import ../build-support/src-only) ({inherit stdenv; } // args);
|
|
|
|
|
2006-12-11 01:24:42 +03:00
|
|
|
substituteAll = import ../build-support/substitute/substitute-all.nix {
|
2007-11-17 17:34:34 +03:00
|
|
|
inherit stdenv;
|
2006-11-03 01:44:32 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
nukeReferences = callPackage ../build-support/nuke-references/default.nix { };
|
2008-03-17 20:29:07 +03:00
|
|
|
|
|
|
|
vmTools = import ../build-support/vm/default.nix {
|
|
|
|
inherit pkgs;
|
|
|
|
};
|
2008-06-19 02:48:34 +04:00
|
|
|
|
2008-11-24 18:10:06 +03:00
|
|
|
releaseTools = import ../build-support/release/default.nix {
|
|
|
|
inherit pkgs;
|
|
|
|
};
|
|
|
|
|
2008-12-20 04:20:35 +03:00
|
|
|
composableDerivation = (import ../lib/composable-derivation.nix) {
|
|
|
|
inherit pkgs lib;
|
|
|
|
};
|
2006-11-03 16:33:24 +03:00
|
|
|
|
Simplified much more the expressions for cross building and multiplatform.
I introduce the new nixpkgs parameter "platform", defaulting to "pc",
which was before defined as an attribute of nixpkgs.
I made the crossSystem nixpkgs attribute set parameter contain its own 'platform'.
This allows cross-building a kernel for a given crossSystem.platform in a non-PC
platform.
The actual native platform can be taken from stdenv.platform, and this way we also
avoid the constant passing of 'platform' to packages for platform-dependant builds
(kernel, initrd, ...).
I will update nixos accordingly to these changes, for non-PC platforms to work.
I think we are gaining on flexibility and clearness. I could cross build succesfully
an ultrasparc kernel and a mipsel kernel on PC. But since this change, I should be able
to do this also in non-PC.
Before this change, there was no possibility of distinguishing the "target platform" or
the "native build platform" when cross building, being the single "platform" attribute
always interpreted as target platform.
The platform is a quite relevant attribute set, as it determines the linuxHeaders used
(in the case, by now the only one supported, of linux targets).
The platform attributes are quite linux centric still. Let's hope for more generality to come.
svn path=/nixpkgs/trunk/; revision=20273
2010-02-27 20:35:47 +03:00
|
|
|
platforms = import ./platforms.nix;
|
2009-11-08 03:32:12 +03:00
|
|
|
|
|
|
|
|
2003-11-03 21:21:30 +03:00
|
|
|
### TOOLS
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
acct = callPackage ../tools/system/acct { };
|
2009-09-08 12:29:40 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
aefs = callPackage ../tools/filesystems/aefs { };
|
2007-04-08 03:38:01 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
aircrackng = callPackage ../tools/networking/aircrack-ng { };
|
2009-02-02 00:21:12 +03:00
|
|
|
|
2012-02-04 14:32:07 +04:00
|
|
|
analog = callPackage ../tools/admin/analog {};
|
|
|
|
|
2011-07-13 16:33:54 +04:00
|
|
|
archivemount = callPackage ../tools/filesystems/archivemount { };
|
|
|
|
|
2010-02-21 20:36:41 +03:00
|
|
|
asymptote = builderDefsPackage ../tools/graphics/asymptote {
|
|
|
|
inherit freeglut ghostscriptX imagemagick fftw boehmgc
|
|
|
|
mesa ncurses readline gsl libsigsegv python zlib perl
|
|
|
|
texinfo lzma;
|
|
|
|
texLive = texLiveAggregationFun {
|
|
|
|
paths = [
|
|
|
|
texLive texLiveExtra
|
|
|
|
];
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ec2apitools = callPackage ../tools/virtualization/amazon-ec2-api-tools { };
|
2009-10-27 15:51:09 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ec2amitools = callPackage ../tools/virtualization/amazon-ec2-ami-tools { };
|
2009-10-27 15:51:09 +03:00
|
|
|
|
2010-10-21 16:28:14 +04:00
|
|
|
altermime = callPackage ../tools/networking/altermime {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
amule = callPackage ../tools/networking/p2p/amule { };
|
2007-10-06 19:59:35 +04:00
|
|
|
|
2010-11-09 02:45:58 +03:00
|
|
|
amuleDaemon = appendToName "daemon" (amule.override {
|
2010-09-18 15:26:30 +04:00
|
|
|
monolithic = false;
|
|
|
|
daemon = true;
|
2010-11-09 02:45:58 +03:00
|
|
|
});
|
2010-10-04 13:49:25 +04:00
|
|
|
|
2010-11-09 02:45:58 +03:00
|
|
|
amuleGui = appendToName "gui" (amule.override {
|
2010-09-18 15:26:30 +04:00
|
|
|
monolithic = false;
|
|
|
|
client = true;
|
2010-11-09 02:45:58 +03:00
|
|
|
});
|
2010-10-04 13:49:25 +04:00
|
|
|
|
2011-04-30 13:21:38 +04:00
|
|
|
aria = builderDefsPackage (import ../tools/networking/aria) { };
|
2008-06-22 00:53:52 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
aria2 = callPackage ../tools/networking/aria2 { };
|
2010-05-20 15:11:24 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
at = callPackage ../tools/system/at { };
|
2008-04-01 13:08:17 +04:00
|
|
|
|
2011-08-29 16:47:39 +04:00
|
|
|
atftp = callPackage ../tools/networking/atftp {};
|
|
|
|
|
2011-02-15 16:14:29 +03:00
|
|
|
autogen = callPackage ../development/tools/misc/autogen {
|
|
|
|
guile = guile_1_8;
|
|
|
|
};
|
2009-09-29 13:01:40 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
autojump = callPackage ../tools/misc/autojump { };
|
2009-05-27 02:05:05 +04:00
|
|
|
|
2011-03-04 16:04:08 +03:00
|
|
|
avahi = callPackage ../development/libraries/avahi {
|
|
|
|
qt4Support = getConfig [ "avahi" "qt4Support" ] false;
|
|
|
|
};
|
2008-02-06 22:36:12 +03:00
|
|
|
|
2011-08-04 16:13:53 +04:00
|
|
|
aws_mturk_clt = callPackage ../tools/misc/aws-mturk-clt { };
|
2008-02-06 22:36:12 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
axel = callPackage ../tools/networking/axel { };
|
2007-08-16 23:50:59 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
azureus = callPackage ../tools/networking/p2p/azureus { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
2011-07-08 02:19:52 +04:00
|
|
|
banner = callPackage ../games/banner {};
|
|
|
|
|
2010-10-08 12:48:34 +04:00
|
|
|
barcode = callPackage ../tools/graphics/barcode {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
bc = callPackage ../tools/misc/bc { };
|
2005-10-10 04:55:07 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
bfr = callPackage ../tools/misc/bfr { };
|
2008-07-12 00:27:53 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
bootchart = callPackage ../tools/system/bootchart { };
|
2009-10-30 02:15:10 +03:00
|
|
|
|
2009-12-04 18:39:49 +03:00
|
|
|
btrfsProgs = builderDefsPackage (import ../tools/filesystems/btrfsprogs) {
|
2011-12-13 22:53:40 +04:00
|
|
|
inherit libuuid zlib acl attr fetchgit;
|
2009-12-04 18:39:49 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
catdoc = callPackage ../tools/text/catdoc { };
|
2010-05-03 07:45:40 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
eggdrop = callPackage ../tools/networking/eggdrop { };
|
2009-10-08 11:01:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mcrl = callPackage ../tools/misc/mcrl { };
|
2009-06-05 18:36:35 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mcrl2 = callPackage ../tools/misc/mcrl2 { };
|
2009-06-05 18:36:35 +04:00
|
|
|
|
2011-08-04 19:59:14 +04:00
|
|
|
syslogng = callPackage ../tools/system/syslog-ng { };
|
2009-02-05 19:50:45 +03:00
|
|
|
|
2012-02-25 00:20:59 +04:00
|
|
|
mcelog = callPackage ../os-specific/linux/mcelog { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
asciidoc = callPackage ../tools/typesetting/asciidoc { };
|
2008-03-10 18:57:14 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
autossh = callPackage ../tools/networking/autossh { };
|
2010-05-27 23:43:57 +04:00
|
|
|
|
2011-08-05 23:18:02 +04:00
|
|
|
bacula = callPackage ../tools/backup/bacula { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
bibtextools = callPackage ../tools/typesetting/bibtex-tools {
|
2009-03-19 17:34:16 +03:00
|
|
|
inherit (strategoPackages016) strategoxt sdf;
|
2006-10-18 18:04:55 +04:00
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
bittorrent = callPackage ../tools/networking/p2p/bittorrent {
|
2006-12-13 23:30:09 +03:00
|
|
|
gui = true;
|
2006-09-15 19:28:53 +04:00
|
|
|
};
|
|
|
|
|
2012-02-22 03:35:35 +04:00
|
|
|
bittornado = callPackage ../tools/networking/p2p/bit-tornado { };
|
2007-06-20 03:38:01 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
blueman = callPackage ../tools/bluetooth/blueman {
|
2010-07-06 18:54:22 +04:00
|
|
|
inherit (pythonPackages) notify;
|
|
|
|
};
|
|
|
|
|
2009-11-18 12:39:59 +03:00
|
|
|
bmrsa = builderDefsPackage (import ../tools/security/bmrsa/11.nix) {
|
2008-12-05 00:01:26 +03:00
|
|
|
inherit unzip;
|
2008-03-03 15:30:39 +03:00
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
bogofilter = callPackage ../tools/misc/bogofilter {
|
2008-03-02 21:35:04 +03:00
|
|
|
bdb = db4;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
bsdiff = callPackage ../tools/compression/bsdiff { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
2011-12-10 01:18:09 +04:00
|
|
|
btar = callPackage ../tools/backup/btar { };
|
|
|
|
|
2011-08-11 20:33:47 +04:00
|
|
|
bup = callPackage ../tools/backup/bup { };
|
|
|
|
|
2010-08-06 14:34:34 +04:00
|
|
|
bzip2 = callPackage ../tools/compression/bzip2 { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cabextract = callPackage ../tools/archivers/cabextract { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ccid = callPackage ../tools/security/ccid { };
|
2010-01-09 20:35:57 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ccrypt = callPackage ../tools/security/ccrypt { };
|
2009-01-13 00:12:07 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cdecl = callPackage ../development/tools/cdecl { };
|
2009-01-25 00:01:27 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cdrdao = callPackage ../tools/cd-dvd/cdrdao { };
|
2008-07-25 17:04:51 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cdrkit = callPackage ../tools/cd-dvd/cdrkit { };
|
2008-07-25 17:04:51 +04:00
|
|
|
|
2010-02-22 13:46:49 +03:00
|
|
|
cfdg = builderDefsPackage ../tools/graphics/cfdg {
|
|
|
|
inherit libpng bison flex;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
checkinstall = callPackage ../tools/package-management/checkinstall { };
|
2008-11-25 05:20:41 +03:00
|
|
|
|
2009-11-18 12:39:59 +03:00
|
|
|
cheetahTemplate = builderDefsPackage (import ../tools/text/cheetah-template/2.0.1.nix) {
|
2008-09-24 12:50:32 +04:00
|
|
|
inherit makeWrapper python;
|
2008-08-15 02:04:30 +04:00
|
|
|
};
|
2008-06-12 14:07:54 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
chkrootkit = callPackage ../tools/security/chkrootkit { };
|
2008-01-14 17:43:24 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cksfv = callPackage ../tools/networking/cksfv { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
2011-04-17 12:26:56 +04:00
|
|
|
colordiff = callPackage ../tools/text/colordiff { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
convertlit = callPackage ../tools/text/convertlit { };
|
2008-08-12 23:57:35 +04:00
|
|
|
|
2012-01-30 23:05:24 +04:00
|
|
|
cowsay = callPackage ../tools/misc/cowsay { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
unifdef = callPackage ../development/tools/misc/unifdef { };
|
2008-08-29 17:53:28 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
usb_modeswitch = callPackage ../development/tools/misc/usb-modeswitch { };
|
2010-04-16 19:56:28 +04:00
|
|
|
|
2011-04-01 01:25:08 +04:00
|
|
|
cloog = callPackage ../development/libraries/cloog { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cloogppl = callPackage ../development/libraries/cloog-ppl { };
|
2009-07-19 01:28:10 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
convmv = callPackage ../tools/misc/convmv { };
|
2010-07-03 12:06:01 +04:00
|
|
|
|
2010-08-06 14:34:34 +04:00
|
|
|
coreutils = callPackage (if stdenv ? isDietLibC
|
|
|
|
then ../tools/misc/coreutils-5
|
|
|
|
else ../tools/misc/coreutils)
|
2006-10-28 00:08:53 +04:00
|
|
|
{
|
2010-05-21 17:46:54 +04:00
|
|
|
# TODO: Add ACL support for cross-Linux.
|
2010-08-06 14:34:34 +04:00
|
|
|
aclSupport = crossSystem == null && stdenv.isLinux;
|
2009-11-08 03:32:12 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cpio = callPackage ../tools/archivers/cpio { };
|
2003-11-02 20:42:19 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cromfs = callPackage ../tools/archivers/cromfs { };
|
2009-01-04 20:24:11 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cron = callPackage ../tools/system/cron { # see also fcron
|
2007-01-10 18:44:58 +03:00
|
|
|
};
|
|
|
|
|
2010-08-06 01:06:45 +04:00
|
|
|
curl = makeOverridable (import ../tools/networking/curl) rec {
|
2008-05-27 11:49:55 +04:00
|
|
|
fetchurl = fetchurlBoot;
|
2010-08-06 01:06:45 +04:00
|
|
|
inherit stdenv zlib openssl libssh2;
|
2008-06-06 11:50:52 +04:00
|
|
|
zlibSupport = ! ((stdenv ? isDietLibC) || (stdenv ? isStatic));
|
2010-08-06 01:06:45 +04:00
|
|
|
sslSupport = zlibSupport;
|
2010-08-12 15:54:55 +04:00
|
|
|
scpSupport = zlibSupport && !stdenv.isSunOS && !stdenv.isCygwin;
|
2008-05-27 11:49:55 +04:00
|
|
|
};
|
2006-09-15 19:28:53 +04:00
|
|
|
|
2011-09-07 05:12:38 +04:00
|
|
|
cunit = callPackage ../tools/misc/cunit { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
curlftpfs = callPackage ../tools/filesystems/curlftpfs { };
|
2007-10-25 18:07:50 +04:00
|
|
|
|
2009-07-07 14:04:32 +04:00
|
|
|
dadadodo = builderDefsPackage (import ../tools/text/dadadodo) {
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dar = callPackage ../tools/archivers/dar { };
|
2009-01-03 18:11:52 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
davfs2 = callPackage ../tools/filesystems/davfs2 {
|
2011-04-17 12:27:29 +04:00
|
|
|
neon = neon029;
|
2009-12-08 16:08:27 +03:00
|
|
|
};
|
|
|
|
|
2011-08-25 05:00:25 +04:00
|
|
|
dbench = callPackage ../development/tools/misc/dbench { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dcraw = callPackage ../tools/graphics/dcraw { };
|
2009-04-06 21:50:17 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
debootstrap = callPackage ../tools/misc/debootstrap { };
|
2009-10-08 04:54:31 +04:00
|
|
|
|
2010-09-06 11:21:08 +04:00
|
|
|
detox = callPackage ../tools/misc/detox { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ddclient = callPackage ../tools/networking/ddclient { };
|
2009-09-16 15:53:09 +04:00
|
|
|
|
2010-11-22 11:40:10 +03:00
|
|
|
dd_rescue = callPackage ../tools/system/dd_rescue { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ddrescue = callPackage ../tools/system/ddrescue { };
|
2008-06-19 02:48:34 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
desktop_file_utils = callPackage ../tools/misc/desktop-file-utils { };
|
2009-02-27 16:44:31 +03:00
|
|
|
|
2010-11-30 17:46:07 +03:00
|
|
|
dev86 = callPackage ../development/compilers/dev86 {
|
|
|
|
/* Using GNU Make 3.82 leads to this:
|
|
|
|
make[4]: *** No rule to make target `__ldivmod.o)'
|
|
|
|
So use 3.81. */
|
|
|
|
stdenv = overrideInStdenv stdenv [gnumake381];
|
|
|
|
};
|
2009-01-25 17:31:24 +03:00
|
|
|
|
2012-02-16 22:03:12 +04:00
|
|
|
dnsmasq = callPackage ../tools/networking/dnsmasq { };
|
2007-09-03 16:10:57 +04:00
|
|
|
|
2011-11-03 22:43:48 +04:00
|
|
|
dnstop = callPackage ../tools/networking/dnstop { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dhcp = callPackage ../tools/networking/dhcp { };
|
2006-08-26 13:44:39 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dhcpcd = callPackage ../tools/networking/dhcpcd { };
|
2009-07-17 15:41:19 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
diffstat = callPackage ../tools/text/diffstat { };
|
2008-05-14 11:58:32 +04:00
|
|
|
|
2010-08-06 14:34:34 +04:00
|
|
|
diffutils = callPackage ../tools/text/diffutils { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dirmngr = callPackage ../tools/security/dirmngr { };
|
2010-05-20 00:58:56 +04:00
|
|
|
|
2011-10-14 22:04:34 +04:00
|
|
|
disper = callPackage ../tools/misc/disper { };
|
|
|
|
|
2011-01-22 15:28:59 +03:00
|
|
|
dmg2img = callPackage ../tools/misc/dmg2img { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
docbook2x = callPackage ../tools/typesetting/docbook2x {
|
2009-04-20 16:49:35 +04:00
|
|
|
inherit (perlPackages) XMLSAX XMLParser XMLNamespaceSupport;
|
2009-12-03 01:19:49 +03:00
|
|
|
libiconv = if stdenv.isDarwin then libiconv else null;
|
2008-03-11 12:34:17 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dosfstools = callPackage ../tools/filesystems/dosfstools { };
|
2008-02-04 07:41:55 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dotnetfx35 = callPackage ../development/libraries/dotnetfx35 { };
|
2010-06-15 15:16:35 +04:00
|
|
|
|
2011-10-04 17:28:32 +04:00
|
|
|
dotnetfx40 = callPackage ../development/libraries/dotnetfx40 { };
|
2010-06-15 15:16:35 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
dropbear = callPackage ../tools/networking/dropbear {
|
2010-03-10 02:11:12 +03:00
|
|
|
enableStatic = true;
|
|
|
|
zlib = zlibStatic;
|
|
|
|
};
|
|
|
|
|
2011-11-21 01:48:56 +04:00
|
|
|
dtach = callPackage ../tools/misc/dtach { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
duplicity = callPackage ../tools/backup/duplicity {
|
2010-02-10 21:10:22 +03:00
|
|
|
inherit (pythonPackages) boto;
|
2010-05-20 00:59:20 +04:00
|
|
|
gnupg = gnupg1;
|
2010-02-04 16:42:41 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dvdplusrwtools = callPackage ../tools/cd-dvd/dvd+rw-tools { };
|
2008-07-25 17:04:51 +04:00
|
|
|
|
2011-08-24 18:55:48 +04:00
|
|
|
dvgrab = callPackage ../tools/video/dvgrab { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
e2fsprogs = callPackage ../tools/filesystems/e2fsprogs { };
|
2009-12-04 18:39:49 +03:00
|
|
|
|
2010-08-16 16:40:03 +04:00
|
|
|
ebook_tools = callPackage ../tools/text/ebook-tools { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ecryptfs = callPackage ../tools/security/ecryptfs { };
|
2010-01-25 13:34:47 +03:00
|
|
|
|
2012-03-14 08:18:52 +04:00
|
|
|
edk2 = callPackage ../development/compilers/edk2 {
|
|
|
|
};
|
|
|
|
|
2011-03-22 16:21:24 +03:00
|
|
|
efibootmgr = callPackage ../tools/system/efibootmgr { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
enblendenfuse = callPackage ../tools/graphics/enblend-enfuse { };
|
2009-04-06 01:41:38 +04:00
|
|
|
|
2010-11-28 12:59:13 +03:00
|
|
|
encfs = callPackage ../tools/filesystems/encfs { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
enscript = callPackage ../tools/text/enscript { };
|
2005-07-21 15:26:51 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ethtool = callPackage ../tools/misc/ethtool { };
|
2005-08-23 18:19:16 +04:00
|
|
|
|
2011-03-30 18:37:53 +04:00
|
|
|
euca2ools = callPackage ../tools/virtualization/euca2ools { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
exif = callPackage ../tools/graphics/exif { };
|
2009-10-11 19:52:27 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
exiftags = callPackage ../tools/graphics/exiftags { };
|
2008-02-27 18:48:53 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
expect = callPackage ../tools/misc/expect { };
|
2008-11-05 00:40:39 +03:00
|
|
|
|
2011-01-06 13:43:32 +03:00
|
|
|
fakeroot = callPackage ../tools/system/fakeroot { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
fcron = callPackage ../tools/system/fcron { # see also cron
|
2009-08-10 02:15:40 +04:00
|
|
|
};
|
|
|
|
|
2011-10-30 04:00:48 +04:00
|
|
|
fdisk = callPackage ../tools/system/fdisk { };
|
2009-04-26 15:06:48 +04:00
|
|
|
|
2010-10-22 02:03:36 +04:00
|
|
|
fdm = callPackage ../tools/networking/fdm {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
figlet = callPackage ../tools/misc/figlet { };
|
|
|
|
|
|
|
|
file = callPackage ../tools/misc/file { };
|
2006-08-08 04:09:27 +04:00
|
|
|
|
2010-10-28 15:10:09 +04:00
|
|
|
fileschanged = callPackage ../tools/misc/fileschanged { };
|
|
|
|
|
2010-08-06 14:34:34 +04:00
|
|
|
findutils =
|
|
|
|
if stdenv.isDarwin
|
|
|
|
then findutils4227
|
|
|
|
else callPackage ../tools/misc/findutils { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
findutils4227 = callPackage ../tools/misc/findutils/4.2.27.nix { };
|
2006-10-28 02:50:58 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
finger_bsd = callPackage ../tools/networking/bsd-finger { };
|
2008-01-28 22:51:14 +03:00
|
|
|
|
2010-11-26 23:04:07 +03:00
|
|
|
flvstreamer = callPackage ../tools/networking/flvstreamer { };
|
|
|
|
|
2012-02-05 04:51:35 +04:00
|
|
|
libbsd = callPackage ../development/libraries/libbsd { };
|
|
|
|
|
2011-09-09 01:48:10 +04:00
|
|
|
flvtool2 = callPackage ../tools/video/flvtool2 { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
fontforge = callPackage ../tools/misc/fontforge { };
|
2007-08-21 16:31:33 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
fontforgeX = callPackage ../tools/misc/fontforge {
|
2010-07-30 16:10:24 +04:00
|
|
|
withX11 = true;
|
2008-03-26 15:57:30 +03:00
|
|
|
};
|
2008-03-03 01:02:28 +03:00
|
|
|
|
2011-01-24 10:06:17 +03:00
|
|
|
freeipmi = callPackage ../tools/system/freeipmi {};
|
|
|
|
|
2011-02-17 01:21:29 +03:00
|
|
|
freetalk = callPackage ../applications/networking/instant-messengers/freetalk {
|
|
|
|
guile = guile_1_8;
|
|
|
|
};
|
2010-12-29 22:20:55 +03:00
|
|
|
|
2011-11-11 02:20:48 +04:00
|
|
|
freetds = callPackage ../development/libraries/freetds { };
|
|
|
|
|
2010-10-20 14:53:45 +04:00
|
|
|
ftgl = callPackage ../development/libraries/ftgl { };
|
|
|
|
|
2012-03-02 17:47:37 +04:00
|
|
|
ftgl212 = callPackage ../development/libraries/ftgl/2.1.2.nix { };
|
|
|
|
|
2011-07-28 01:00:09 +04:00
|
|
|
fuppes = callPackage ../tools/networking/fuppes {
|
|
|
|
ffmpeg = ffmpeg_0_6_90;
|
|
|
|
};
|
2010-01-14 00:09:55 +03:00
|
|
|
|
2011-04-01 01:08:50 +04:00
|
|
|
fsfs = callPackage ../tools/filesystems/fsfs { };
|
|
|
|
|
2012-02-08 19:45:26 +04:00
|
|
|
fuse_zip = callPackage ../tools/filesystems/fuse-zip { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dos2unix = callPackage ../tools/text/dos2unix { };
|
2010-01-14 00:09:55 +03:00
|
|
|
|
2010-09-28 13:48:15 +04:00
|
|
|
uni2ascii = callPackage ../tools/text/uni2ascii { };
|
|
|
|
|
2010-08-06 14:34:34 +04:00
|
|
|
gawk = callPackage ../tools/text/gawk { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gdmap = callPackage ../tools/system/gdmap {
|
2011-02-12 23:16:08 +03:00
|
|
|
inherit (pkgs.gtkLibs) gtk;
|
2007-12-01 19:20:23 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
genext2fs = callPackage ../tools/filesystems/genext2fs { };
|
2009-12-04 18:39:49 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gengetopt = callPackage ../development/tools/misc/gengetopt { };
|
2010-01-22 20:00:44 +03:00
|
|
|
|
2011-03-28 17:13:15 +04:00
|
|
|
getmail = callPackage ../tools/networking/getmail { };
|
2010-10-17 23:30:59 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
getopt = callPackage ../tools/misc/getopt { };
|
2005-10-08 03:02:58 +04:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
gftp = callPackage ../tools/networking/gftp { };
|
2008-08-07 00:39:01 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gifsicle = callPackage ../tools/graphics/gifsicle { };
|
2008-06-22 06:07:53 +04:00
|
|
|
|
2009-12-04 18:39:49 +03:00
|
|
|
glusterfs = builderDefsPackage ../tools/filesystems/glusterfs {
|
2010-12-13 00:48:29 +03:00
|
|
|
inherit fuse flex bison;
|
2009-08-31 13:52:01 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
glxinfo = callPackage ../tools/graphics/glxinfo { };
|
2007-04-18 18:21:24 +04:00
|
|
|
|
2009-06-10 13:45:03 +04:00
|
|
|
gnokii = builderDefsPackage (import ../tools/misc/gnokii) {
|
2011-03-16 02:09:14 +03:00
|
|
|
inherit intltool perl gettext libusb pkgconfig bluez readline pcsclite
|
|
|
|
libical;
|
2010-09-09 20:48:13 +04:00
|
|
|
inherit (gtkLibs) gtk glib;
|
2011-03-16 02:09:14 +03:00
|
|
|
inherit (xorg) libXpm;
|
2009-06-10 13:45:03 +04:00
|
|
|
};
|
|
|
|
|
2010-11-09 16:12:31 +03:00
|
|
|
gnugrep =
|
|
|
|
# Use libiconv only on non-GNU platforms (we can't test with
|
|
|
|
# `stdenv ? glibc' at this point.)
|
|
|
|
let gnu = stdenv.isLinux; in
|
|
|
|
callPackage ../tools/text/gnugrep {
|
|
|
|
libiconv = if gnu then null else libiconv;
|
|
|
|
};
|
2003-11-02 21:14:24 +03:00
|
|
|
|
2010-08-06 14:34:34 +04:00
|
|
|
gnupatch = callPackage ../tools/text/gnupatch { };
|
2004-02-13 17:42:28 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gnupg1orig = callPackage ../tools/security/gnupg1 {
|
2010-05-19 16:25:45 +04:00
|
|
|
ideaSupport = false;
|
2006-09-15 19:28:53 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gnupg1compat = callPackage ../tools/security/gnupg1compat { };
|
2010-05-20 00:59:20 +04:00
|
|
|
|
|
|
|
# use config.packageOverrides if you prefer original gnupg1
|
|
|
|
gnupg1 = gnupg1compat;
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gnupg = callPackage ../tools/security/gnupg { };
|
2008-01-28 22:45:57 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gnuplot = callPackage ../tools/graphics/gnuplot {
|
2009-09-09 13:36:03 +04:00
|
|
|
inherit (gtkLibs) pango;
|
2010-07-28 19:35:01 +04:00
|
|
|
texLive = null;
|
|
|
|
lua = null;
|
2007-08-04 19:12:14 +04:00
|
|
|
};
|
|
|
|
|
2010-08-06 14:34:34 +04:00
|
|
|
gnused = callPackage ../tools/text/gnused { };
|
2003-11-02 20:42:19 +03:00
|
|
|
|
2010-08-06 14:34:34 +04:00
|
|
|
gnutar = callPackage ../tools/archivers/gnutar { };
|
2003-11-02 21:14:24 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gnuvd = callPackage ../tools/misc/gnuvd { };
|
2009-09-16 12:36:05 +04:00
|
|
|
|
2012-01-15 15:44:02 +04:00
|
|
|
gource = callPackage ../applications/version-management/gource {};
|
2010-10-20 14:53:45 +04:00
|
|
|
|
2011-03-15 00:13:35 +03:00
|
|
|
gptfdisk = callPackage ../tools/system/gptfdisk { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
graphviz = callPackage ../tools/graphics/graphviz {
|
2008-07-03 18:27:19 +04:00
|
|
|
inherit (gtkLibs) pango;
|
2006-09-15 19:28:53 +04:00
|
|
|
};
|
|
|
|
|
2010-07-26 17:41:09 +04:00
|
|
|
/* Readded by Michael Raskin. There are programs in the wild
|
2010-07-05 23:04:33 +04:00
|
|
|
* that do want 2.0 but not 2.22. Please give a day's notice for
|
|
|
|
* objections before removal.
|
|
|
|
*/
|
2010-08-03 01:40:34 +04:00
|
|
|
graphviz_2_0 = callPackage ../tools/graphics/graphviz/2.0.nix {
|
2010-09-09 20:48:13 +04:00
|
|
|
inherit (gtkLibs) pango;
|
|
|
|
};
|
2010-07-05 23:04:33 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
groff = callPackage ../tools/text/groff {
|
2009-02-13 01:33:17 +03:00
|
|
|
ghostscript = null;
|
2005-08-21 17:59:04 +04:00
|
|
|
};
|
|
|
|
|
2010-12-06 17:25:58 +03:00
|
|
|
grub = callPackage_i686 ../tools/misc/grub {
|
|
|
|
buggyBiosCDSupport = getConfig ["grub" "buggyBiosCDSupport"] true;
|
2008-06-29 20:13:02 +04:00
|
|
|
};
|
2004-06-03 21:16:16 +04:00
|
|
|
|
2011-04-09 13:25:06 +04:00
|
|
|
grub19x = callPackage ../tools/misc/grub/1.9x.nix { };
|
2011-04-01 01:15:53 +04:00
|
|
|
|
2011-04-09 13:25:06 +04:00
|
|
|
grub2 = grub19x;
|
|
|
|
|
2011-11-06 21:08:05 +04:00
|
|
|
grub2_efi = callPackage ../tools/misc/grub/1.9x.nix { EFIsupport = true; };
|
2009-10-05 01:39:34 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gssdp = callPackage ../development/libraries/gssdp {
|
2008-06-29 20:13:02 +04:00
|
|
|
inherit (gnome) libsoup;
|
|
|
|
};
|
2008-06-18 23:40:56 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gt5 = callPackage ../tools/system/gt5 { };
|
2010-02-24 22:06:25 +03:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
gtkgnutella = callPackage ../tools/networking/p2p/gtk-gnutella { };
|
2005-06-21 00:35:07 +04:00
|
|
|
|
2011-01-14 01:21:09 +03:00
|
|
|
gtkvnc = callPackage ../tools/admin/gtk-vnc {};
|
2005-06-21 00:35:07 +04:00
|
|
|
|
2011-11-04 14:28:18 +04:00
|
|
|
gtmess = callPackage ../applications/networking/instant-messengers/gtmess { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gupnp = callPackage ../development/libraries/gupnp {
|
2008-06-29 20:13:02 +04:00
|
|
|
inherit (gnome) libsoup;
|
|
|
|
};
|
2008-06-18 23:40:56 +04:00
|
|
|
|
2012-03-13 23:06:17 +04:00
|
|
|
gupnp_igd = callPackage ../development/libraries/gupnp-igd {};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gupnptools = callPackage ../tools/networking/gupnp-tools {
|
2008-06-29 20:13:02 +04:00
|
|
|
inherit (gnome) libsoup libglade gnomeicontheme;
|
2008-06-19 02:34:49 +04:00
|
|
|
};
|
|
|
|
|
2009-09-02 00:12:01 +04:00
|
|
|
gvpe = builderDefsPackage ../tools/networking/gvpe {
|
2009-09-02 02:42:05 +04:00
|
|
|
inherit openssl gmp nettools iproute;
|
2009-09-02 00:12:01 +04:00
|
|
|
};
|
|
|
|
|
2010-08-06 14:34:34 +04:00
|
|
|
gzip = callPackage ../tools/compression/gzip { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pigz = callPackage ../tools/compression/pigz { };
|
2009-10-08 00:18:11 +04:00
|
|
|
|
2012-01-30 15:40:20 +04:00
|
|
|
hardlink = callPackage ../tools/system/hardlink { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
halibut = callPackage ../tools/typesetting/halibut { };
|
2009-03-30 00:32:22 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
hddtemp = callPackage ../tools/misc/hddtemp { };
|
2007-12-11 01:36:52 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
hdf5 = callPackage ../tools/misc/hdf5 { };
|
2011-02-24 14:25:16 +03:00
|
|
|
|
2011-08-21 04:10:12 +04:00
|
|
|
heimdall = callPackage ../tools/misc/heimdall { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
hevea = callPackage ../tools/typesetting/hevea { };
|
2004-08-21 02:06:36 +04:00
|
|
|
|
2011-09-06 21:10:08 +04:00
|
|
|
highlight = callPackage ../tools/text/highlight {
|
|
|
|
lua = lua5;
|
|
|
|
};
|
2008-06-12 19:59:59 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
host = callPackage ../tools/networking/host { };
|
2008-11-27 16:54:49 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
httpfs2 = callPackage ../tools/filesystems/httpfs { };
|
2010-06-17 16:44:40 +04:00
|
|
|
|
2011-12-02 02:43:10 +04:00
|
|
|
# FIXME: This Hydra snapshot is outdated and depends on the `nixPerl',
|
|
|
|
# which no longer exists.
|
|
|
|
#
|
|
|
|
# hydra = callPackage ../development/tools/misc/hydra {
|
|
|
|
# nix = nixUnstable;
|
|
|
|
# };
|
2011-01-14 17:47:48 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
iasl = callPackage ../development/compilers/iasl { };
|
2009-01-26 00:03:07 +03:00
|
|
|
|
2012-01-04 13:42:38 +04:00
|
|
|
icoutils = callPackage ../tools/graphics/icoutils { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
idutils = callPackage ../tools/misc/idutils { };
|
2008-03-27 14:09:40 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
iftop = callPackage ../tools/networking/iftop { };
|
2009-10-08 11:01:55 +04:00
|
|
|
|
2011-11-09 22:25:55 +04:00
|
|
|
imapproxy = callPackage ../tools/networking/imapproxy { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
imapsync = callPackage ../tools/networking/imapsync {
|
2009-06-15 22:37:42 +04:00
|
|
|
inherit (perlPackages) MailIMAPClient;
|
2008-03-27 14:09:40 +03:00
|
|
|
};
|
|
|
|
|
2011-04-08 00:26:26 +04:00
|
|
|
inadyn = callPackage ../tools/networking/inadyn { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
inetutils = callPackage ../tools/networking/inetutils { };
|
2008-02-21 21:58:11 +03:00
|
|
|
|
2011-06-07 19:56:50 +04:00
|
|
|
ioping = callPackage ../tools/system/ioping {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
iodine = callPackage ../tools/networking/iodine { };
|
2008-05-14 12:01:03 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
iperf = callPackage ../tools/networking/iperf { };
|
2009-03-16 21:39:04 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
ipmitool = callPackage ../tools/system/ipmitool {
|
2010-05-19 16:25:48 +04:00
|
|
|
static = false;
|
2010-01-19 18:58:19 +03:00
|
|
|
};
|
|
|
|
|
2011-01-21 22:34:54 +03:00
|
|
|
ipmiutil = callPackage ../tools/system/ipmiutil {};
|
2011-01-21 22:15:10 +03:00
|
|
|
|
2011-01-01 23:28:38 +03:00
|
|
|
ised = callPackage ../tools/misc/ised {};
|
|
|
|
|
2011-04-01 01:19:39 +04:00
|
|
|
isl = callPackage ../development/libraries/isl { };
|
|
|
|
|
2011-02-08 02:07:21 +03:00
|
|
|
isync = callPackage ../tools/networking/isync { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jdiskreport = callPackage ../tools/misc/jdiskreport { };
|
2005-10-27 01:10:31 +04:00
|
|
|
|
2011-07-13 14:56:52 +04:00
|
|
|
jfsrec = callPackage ../tools/filesystems/jfsrec {
|
|
|
|
boost = boost144;
|
|
|
|
};
|
2009-12-04 18:39:49 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jfsutils = callPackage ../tools/filesystems/jfsutils { };
|
2009-12-04 18:39:49 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jhead = callPackage ../tools/graphics/jhead { };
|
2009-10-11 19:52:14 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jing = callPackage ../tools/text/xml/jing { };
|
2005-10-24 18:01:08 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jing_tools = callPackage ../tools/text/xml/jing/jing-script.nix { };
|
2004-09-26 17:03:59 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
jnettop = callPackage ../tools/networking/jnettop {
|
2008-12-03 17:22:55 +03:00
|
|
|
inherit (gnome) glib;
|
|
|
|
};
|
|
|
|
|
2011-06-21 11:28:30 +04:00
|
|
|
jscoverage = callPackage ../development/tools/misc/jscoverage { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jwhois = callPackage ../tools/networking/jwhois { };
|
2007-08-28 18:45:00 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
keychain = callPackage ../tools/misc/keychain { };
|
2008-04-23 14:51:23 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
kismet = callPackage ../applications/networking/sniffers/kismet { };
|
2009-02-02 00:21:27 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
less = callPackage ../tools/misc/less { };
|
2006-07-04 23:17:34 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
most = callPackage ../tools/misc/most { };
|
2010-04-30 13:21:18 +04:00
|
|
|
|
2011-10-26 00:49:22 +04:00
|
|
|
netperf = callPackage ../applications/networking/netperf { };
|
|
|
|
|
2011-06-14 19:15:34 +04:00
|
|
|
ninka = callPackage ../development/tools/misc/ninka { };
|
2011-07-08 01:32:55 +04:00
|
|
|
|
2011-05-06 02:38:04 +04:00
|
|
|
nodejs = callPackage ../development/web/nodejs {};
|
|
|
|
|
2011-11-02 02:33:40 +04:00
|
|
|
ldns = callPackage ../development/libraries/ldns { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
lftp = callPackage ../tools/networking/lftp { };
|
2007-08-04 16:41:00 +04:00
|
|
|
|
2011-11-04 01:08:32 +04:00
|
|
|
libtirpc = callPackage ../development/libraries/ti-rpc { };
|
2011-10-26 14:32:40 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libtorrent = callPackage ../tools/networking/p2p/libtorrent { };
|
2008-02-23 15:11:27 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
logrotate = callPackage ../tools/system/logrotate { };
|
2010-04-29 21:55:06 +04:00
|
|
|
|
2012-01-16 15:34:00 +04:00
|
|
|
logstalgica = callPackage ../tools/graphics/logstalgica {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
lout = callPackage ../tools/typesetting/lout { };
|
2008-02-12 12:58:57 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
lrzip = callPackage ../tools/compression/lrzip { };
|
2009-03-18 00:17:51 +03:00
|
|
|
|
2010-11-17 13:43:04 +03:00
|
|
|
# lsh installs `bin/nettle-lfib-stream' and so does Nettle. Give the
|
|
|
|
# former a lower priority than Nettle.
|
|
|
|
lsh = lowPrio (callPackage ../tools/networking/lsh { });
|
2009-03-28 22:28:59 +03:00
|
|
|
|
2010-11-15 12:52:57 +03:00
|
|
|
lshw = callPackage ../tools/system/lshw { };
|
|
|
|
|
2011-09-26 12:12:14 +04:00
|
|
|
lxc = callPackage ../applications/virtualization/lxc { };
|
2010-10-27 01:11:47 +04:00
|
|
|
|
2009-12-18 14:25:56 +03:00
|
|
|
lzma = xz;
|
2009-09-23 00:16:38 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xz = callPackage ../tools/compression/xz { };
|
2008-02-06 16:52:41 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
lzop = callPackage ../tools/compression/lzop { };
|
2008-02-12 13:51:44 +03:00
|
|
|
|
2011-10-24 20:36:03 +04:00
|
|
|
mu0 = callPackage ../tools/networking/mu0 { };
|
|
|
|
|
2011-02-15 16:14:29 +03:00
|
|
|
mailutils = callPackage ../tools/networking/mailutils {
|
|
|
|
guile = guile_1_8;
|
|
|
|
};
|
2009-09-11 13:38:25 +04:00
|
|
|
|
2011-08-02 18:26:47 +04:00
|
|
|
mairix = callPackage ../tools/text/mairix { };
|
2009-09-11 13:38:25 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
man = callPackage ../tools/misc/man { };
|
2008-02-07 17:39:07 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
man_db = callPackage ../tools/misc/man-db { };
|
2006-06-02 01:25:40 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
memtest86 = callPackage ../tools/misc/memtest86 { };
|
2008-01-03 18:14:37 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mc = callPackage ../tools/misc/mc { };
|
2008-01-23 12:57:11 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mcabber = callPackage ../applications/networking/instant-messengers/mcabber { };
|
2009-01-04 20:11:38 +03:00
|
|
|
|
2011-02-15 16:14:29 +03:00
|
|
|
mcron = callPackage ../tools/system/mcron {
|
|
|
|
guile = guile_1_8;
|
|
|
|
};
|
2009-04-03 22:46:26 +04:00
|
|
|
|
2010-12-13 00:48:29 +03:00
|
|
|
mdbtools = callPackage ../tools/misc/mdbtools { };
|
2008-05-11 13:45:26 +04:00
|
|
|
|
2010-12-13 00:48:29 +03:00
|
|
|
mdbtools_git = callPackage ../tools/misc/mdbtools/git.nix { };
|
2010-09-30 20:50:37 +04:00
|
|
|
|
2011-05-17 15:34:18 +04:00
|
|
|
miniupnpc = callPackage ../tools/networking/miniupnpc { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
miniupnpd = callPackage ../tools/networking/miniupnpd { };
|
2010-05-21 02:11:44 +04:00
|
|
|
|
2011-04-08 02:24:56 +04:00
|
|
|
minixml = callPackage ../development/libraries/minixml { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mjpegtools = callPackage ../tools/video/mjpegtools { };
|
2003-11-07 14:18:47 +03:00
|
|
|
|
2011-03-06 19:07:31 +03:00
|
|
|
mkcue = callPackage ../tools/cd-dvd/mkcue { };
|
2010-01-21 19:53:16 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mktemp = callPackage ../tools/security/mktemp { };
|
2005-03-21 17:48:48 +03:00
|
|
|
|
2010-10-03 13:18:44 +04:00
|
|
|
mldonkey = callPackage ../applications/networking/p2p/mldonkey { };
|
2009-01-04 20:35:11 +03:00
|
|
|
|
2012-01-04 13:05:22 +04:00
|
|
|
modemmanager = callPackage ../tools/networking/modemmanager {};
|
|
|
|
|
2009-08-26 20:22:20 +04:00
|
|
|
monit = builderDefsPackage ../tools/system/monit {
|
2010-12-13 00:48:29 +03:00
|
|
|
inherit openssl flex bison;
|
2009-08-26 20:22:20 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mpage = callPackage ../tools/text/mpage { };
|
2008-04-11 17:22:35 +04:00
|
|
|
|
2011-10-13 11:38:44 +04:00
|
|
|
mscgen = callPackage ../tools/graphics/mscgen { };
|
|
|
|
|
2009-11-18 12:39:59 +03:00
|
|
|
msf = builderDefsPackage (import ../tools/security/metasploit/3.1.nix) {
|
2008-04-11 13:32:27 +04:00
|
|
|
inherit ruby makeWrapper;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mssys = callPackage ../tools/misc/mssys { };
|
2008-01-30 20:08:38 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mtdutils = callPackage ../tools/filesystems/mtdutils { };
|
2010-04-29 21:54:51 +04:00
|
|
|
|
2010-08-07 01:36:54 +04:00
|
|
|
mtools = callPackage ../tools/filesystems/mtools { };
|
|
|
|
|
2011-01-10 18:57:23 +03:00
|
|
|
mtr = callPackage ../tools/networking/mtr {};
|
|
|
|
|
2010-08-02 17:57:57 +04:00
|
|
|
multitran = recurseIntoAttrs (let callPackage = newScope pkgs.multitran; in rec {
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
multitrandata = callPackage ../tools/text/multitran/data { };
|
2009-03-18 00:49:39 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libbtree = callPackage ../tools/text/multitran/libbtree { };
|
2009-03-18 00:49:39 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libmtsupport = callPackage ../tools/text/multitran/libmtsupport { };
|
2009-03-18 00:49:39 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libfacet = callPackage ../tools/text/multitran/libfacet { };
|
2009-03-18 00:49:39 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libmtquery = callPackage ../tools/text/multitran/libmtquery { };
|
2009-03-18 00:49:39 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mtutils = callPackage ../tools/text/multitran/mtutils { };
|
2010-08-02 17:57:57 +04:00
|
|
|
});
|
2009-03-18 00:49:39 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
muscleframework = callPackage ../tools/security/muscleframework { };
|
2010-01-09 21:06:37 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
muscletool = callPackage ../tools/security/muscletool { };
|
2010-01-09 21:06:37 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mysql2pgsql = callPackage ../tools/misc/mysql2pgsql { };
|
2008-06-01 02:49:00 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
namazu = callPackage ../tools/text/namazu { };
|
2008-12-17 20:09:29 +03:00
|
|
|
|
2011-10-13 11:26:44 +04:00
|
|
|
nbd = callPackage ../tools/networking/nbd { };
|
2008-02-03 11:53:47 +03:00
|
|
|
|
2010-11-17 13:05:46 +03:00
|
|
|
netcdf = callPackage ../development/libraries/netcdf { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
nc6 = callPackage ../tools/networking/nc6 { };
|
2007-07-09 11:23:16 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ncat = callPackage ../tools/networking/ncat { };
|
2009-09-17 11:31:34 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ncftp = callPackage ../tools/networking/ncftp { };
|
2010-01-27 15:12:35 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ncompress = callPackage ../tools/compression/ncompress { };
|
2006-08-27 17:00:20 +04:00
|
|
|
|
2011-03-24 17:30:06 +03:00
|
|
|
ndisc6 = callPackage ../tools/networking/ndisc6 { };
|
2011-04-13 21:53:07 +04:00
|
|
|
|
2011-08-29 14:16:36 +04:00
|
|
|
netboot = callPackage ../tools/networking/netboot {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
netcat = callPackage ../tools/networking/netcat { };
|
2009-08-20 00:19:27 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
netkittftp = callPackage ../tools/networking/netkit/tftp { };
|
2009-02-26 01:44:08 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
netpbm = callPackage ../tools/graphics/netpbm { };
|
2007-08-31 15:14:05 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
netselect = callPackage ../tools/networking/netselect { };
|
2007-08-31 15:14:05 +04:00
|
|
|
|
2011-01-03 21:01:10 +03:00
|
|
|
networkmanager = callPackage ../tools/networking/network-manager { };
|
|
|
|
|
2011-09-14 19:50:14 +04:00
|
|
|
networkmanager_pptp = callPackage ../tools/networking/network-manager/pptp.nix { };
|
|
|
|
|
2012-03-11 18:07:37 +04:00
|
|
|
networkmanager_pptp_gnome = networkmanager_pptp.override { withGnome = true; };
|
|
|
|
|
2011-03-26 21:18:32 +03:00
|
|
|
networkmanagerapplet = newScope gnome ../tools/networking/network-manager-applet { };
|
|
|
|
|
2010-08-21 01:39:22 +04:00
|
|
|
nilfs_utils = callPackage ../tools/filesystems/nilfs-utils {};
|
|
|
|
|
2011-05-04 14:03:46 +04:00
|
|
|
nlopt = callPackage ../development/libraries/nlopt {};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
nmap = callPackage ../tools/security/nmap {
|
2009-07-08 02:34:03 +04:00
|
|
|
inherit (pythonPackages) pysqlite;
|
2004-11-30 00:17:29 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ntfs3g = callPackage ../tools/filesystems/ntfs-3g { };
|
2009-12-04 18:39:49 +03:00
|
|
|
|
2011-12-25 02:28:00 +04:00
|
|
|
# ntfsprogs are merged into ntfs-3g
|
|
|
|
ntfsprogs = pkgs.ntfs3g;
|
2009-12-04 18:39:49 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ntp = callPackage ../tools/networking/ntp { };
|
2006-12-22 01:23:17 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
nssmdns = callPackage ../tools/networking/nss-mdns { };
|
2008-03-17 16:41:54 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
nylon = callPackage ../tools/networking/nylon { };
|
2009-02-26 02:21:44 +03:00
|
|
|
|
2011-04-30 13:21:38 +04:00
|
|
|
nzbget = callPackage ../tools/networking/nzbget { };
|
2011-07-08 01:32:55 +04:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
obex_data_server = callPackage ../tools/bluetooth/obex-data-server { };
|
2010-07-06 18:54:22 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
obexd = callPackage ../tools/bluetooth/obexd { };
|
2009-09-29 16:54:08 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
obexfs = callPackage ../tools/bluetooth/obexfs { };
|
2009-08-06 03:24:27 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
obexftp = callPackage ../tools/bluetooth/obexftp { };
|
2009-08-06 03:24:27 +04:00
|
|
|
|
2011-10-09 22:22:18 +04:00
|
|
|
odt2txt = callPackage ../tools/text/odt2txt { };
|
|
|
|
|
2012-02-22 03:35:35 +04:00
|
|
|
offlineimap = callPackage ../tools/networking/offlineimap { };
|
2010-04-13 01:03:22 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
opendbx = callPackage ../development/libraries/opendbx { };
|
2010-02-09 12:05:14 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
opendkim = callPackage ../development/libraries/opendkim { };
|
2010-02-09 13:32:55 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
openjade = callPackage ../tools/text/sgml/openjade {
|
2009-10-22 19:41:39 +04:00
|
|
|
stdenv = overrideGCC stdenv gcc33;
|
2010-10-04 21:05:22 +04:00
|
|
|
opensp = opensp.override { stdenv = overrideGCC stdenv gcc33; };
|
2009-10-22 19:41:39 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
openobex = callPackage ../tools/bluetooth/openobex { };
|
2009-08-06 03:24:27 +04:00
|
|
|
|
2012-02-16 22:40:05 +04:00
|
|
|
openresolv = callPackage ../tools/networking/openresolv { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
opensc_0_11_7 = callPackage ../tools/security/opensc/0.11.7.nix { };
|
2010-01-10 00:52:31 +03:00
|
|
|
|
2010-01-10 03:22:29 +03:00
|
|
|
opensc = opensc_0_11_7;
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
opensc_dnie_wrapper = callPackage ../tools/security/opensc-dnie-wrapper { };
|
2010-01-15 02:43:56 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
openssh = callPackage ../tools/networking/openssh {
|
2010-05-19 16:26:06 +04:00
|
|
|
hpnSupport = false;
|
|
|
|
etcDir = "/etc/ssh";
|
2011-05-21 12:24:27 +04:00
|
|
|
pam = if stdenv.isLinux then pam else null;
|
2003-11-03 21:21:30 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
opensp = callPackage ../tools/text/sgml/opensp { };
|
2009-10-22 19:41:39 +04:00
|
|
|
|
2010-12-29 21:04:11 +03:00
|
|
|
spCompat = callPackage ../tools/text/sgml/opensp/compat.nix { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
openvpn = callPackage ../tools/networking/openvpn { };
|
2009-04-06 17:07:18 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
optipng = callPackage ../tools/graphics/optipng { };
|
2010-03-24 02:04:41 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
p7zip = callPackage ../tools/archivers/p7zip { };
|
2007-09-04 15:55:19 +04:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
pal = callPackage ../tools/misc/pal { };
|
2010-08-10 01:13:36 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
panomatic = callPackage ../tools/graphics/panomatic { };
|
2009-04-10 13:42:22 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
par2cmdline = callPackage ../tools/networking/par2cmdline { };
|
2003-12-23 23:51:58 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
parallel = callPackage ../tools/misc/parallel { };
|
2010-05-02 13:27:32 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
patchutils = callPackage ../tools/text/patchutils { };
|
2008-07-19 03:36:28 +04:00
|
|
|
|
2011-11-02 02:10:51 +04:00
|
|
|
parted = callPackage ../tools/misc/parted { hurd = null; };
|
|
|
|
parted_2_3 = callPackage ../tools/misc/parted/2.3.nix { hurd = null; };
|
2003-11-04 11:44:46 +03:00
|
|
|
|
2010-12-13 02:35:10 +03:00
|
|
|
hurdPartedCross =
|
|
|
|
if crossSystem != null && crossSystem.config == "i586-pc-gnu"
|
|
|
|
then (callPackage ../tools/misc/parted {
|
|
|
|
# Needs the Hurd's libstore.
|
2011-11-02 02:10:51 +04:00
|
|
|
hurd = gnu.hurdCrossIntermediate;
|
2010-12-13 02:35:10 +03:00
|
|
|
|
|
|
|
# The Hurd wants a libparted.a.
|
|
|
|
enableStatic = true;
|
|
|
|
|
|
|
|
gettext = null;
|
|
|
|
readline = null;
|
|
|
|
devicemapper = null;
|
|
|
|
}).hostDrv
|
|
|
|
else null;
|
2010-12-13 02:21:35 +03:00
|
|
|
|
2007-04-26 17:02:30 +04:00
|
|
|
patch = gnupatch;
|
* The stdenv setup script now defines a generic builder that allows
builders for typical Autoconf-style to be much shorten, e.g.,
. $stdenv/setup
genericBuild
The generic builder does lots of stuff automatically:
- Unpacks source archives specified by $src or $srcs (it knows about
gzip, bzip2, tar, zip, and unpacked source trees).
- Determines the source tree.
- Applies patches specified by $patches.
- Fixes libtool not to search for libraries in /lib etc.
- Runs `configure'.
- Runs `make'.
- Runs `make install'.
- Strips debug information from static libraries.
- Writes nested log information (in the format accepted by
`log2xml').
There are also lots of hooks and variables to customise the generic
builder. See `stdenv/generic/docs.txt'.
* Adapted the base packages (i.e., the ones used by stdenv) to use the
generic builder.
* We now use `curl' instead of `wget' to download files in `fetchurl'.
* Neither `curl' nor `wget' are part of stdenv. We shouldn't
encourage people to download stuff in builders (impure!).
* Updated some packages.
* `buildinputs' is now `buildInputs' (but the old name also works).
* `findInputs' in the setup script now prevents inputs from being
processed multiple times (which could happen, e.g., if an input was
a propagated input of several other inputs; this caused the size
variables like $PATH to blow up exponentially in the worst case).
* Patched GNU Make to write nested log information in the format
accepted by `log2xml'. Also, prior to writing the build command,
Make now writes a line `building X' to indicate what is being
built. This is unfortunately often obscured by the gigantic tool
invocations in many Makefiles. The actual build commands are marked
`unimportant' so that they don't clutter pages generated by
`log2html'.
svn path=/nixpkgs/trunk/; revision=845
2004-03-19 19:53:04 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pbzip2 = callPackage ../tools/compression/pbzip2 { };
|
2009-12-17 14:10:01 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pciutils = callPackage ../tools/system/pciutils { };
|
2007-02-19 23:18:20 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pcsclite = callPackage ../tools/security/pcsclite { };
|
2010-01-09 20:35:57 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pdf2djvu = callPackage ../tools/typesetting/pdf2djvu { };
|
2009-03-30 00:32:41 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pdfjam = callPackage ../tools/typesetting/pdfjam { };
|
2007-03-21 15:53:01 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pdfread = callPackage ../tools/graphics/pdfread { };
|
2010-03-24 02:04:41 +03:00
|
|
|
|
2011-09-22 15:28:56 +04:00
|
|
|
pdnsd = callPackage ../tools/networking/pdnsd { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pg_top = callPackage ../tools/misc/pg_top { };
|
2009-10-08 12:53:21 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
pdsh = callPackage ../tools/networking/pdsh {
|
2010-08-14 20:04:02 +04:00
|
|
|
rsh = true; # enable internal rsh implementation
|
2010-05-19 16:26:00 +04:00
|
|
|
ssh = openssh;
|
2008-07-08 03:11:36 +04:00
|
|
|
};
|
|
|
|
|
2011-09-21 02:49:07 +04:00
|
|
|
pfstools = callPackage ../tools/graphics/pfstools { };
|
2009-04-06 01:41:13 +04:00
|
|
|
|
2010-10-18 09:33:31 +04:00
|
|
|
philter = callPackage ../tools/networking/philter { };
|
|
|
|
|
2011-08-18 16:52:50 +04:00
|
|
|
pinentry = callPackage ../tools/security/pinentry {
|
2008-04-26 03:43:14 +04:00
|
|
|
inherit (gnome) glib gtk;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pius = callPackage ../tools/security/pius { };
|
2010-07-13 20:32:14 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pk2cmd = callPackage ../tools/misc/pk2cmd { };
|
2010-05-11 20:17:26 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
plan9port = callPackage ../tools/system/plan9port { };
|
2009-03-24 00:31:30 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ploticus = callPackage ../tools/graphics/ploticus { };
|
2005-09-01 20:38:31 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
plotutils = callPackage ../tools/graphics/plotutils { };
|
2009-10-18 08:43:50 +04:00
|
|
|
|
2011-09-21 11:33:38 +04:00
|
|
|
pngcrush = callPackage ../tools/graphics/pngcrush { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pngnq = callPackage ../tools/graphics/pngnq { };
|
2010-03-24 01:40:46 +03:00
|
|
|
|
2012-02-25 07:09:36 +04:00
|
|
|
pngtoico = callPackage ../tools/graphics/pngtoico {
|
|
|
|
libpng = libpng12;
|
|
|
|
};
|
2012-01-04 13:29:52 +04:00
|
|
|
|
2011-05-08 03:41:34 +04:00
|
|
|
polipo = callPackage ../servers/polipo { };
|
|
|
|
|
2011-08-18 16:52:50 +04:00
|
|
|
polkit_gnome = callPackage ../tools/security/polkit-gnome { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
povray = callPackage ../tools/graphics/povray { };
|
2009-05-14 12:49:46 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ppl = callPackage ../development/libraries/ppl { };
|
2009-07-19 01:22:13 +04:00
|
|
|
|
2012-01-04 19:10:27 +04:00
|
|
|
ppp = callPackage ../tools/networking/ppp { };
|
2009-02-01 16:54:20 +03:00
|
|
|
|
2011-09-14 12:39:51 +04:00
|
|
|
pptp = callPackage ../tools/networking/pptp {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
proxychains = callPackage ../tools/networking/proxychains { };
|
2009-01-13 00:12:07 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
proxytunnel = callPackage ../tools/misc/proxytunnel { };
|
2008-09-06 16:33:25 +04:00
|
|
|
|
2011-10-10 02:28:41 +04:00
|
|
|
cntlm = callPackage ../tools/networking/cntlm { };
|
|
|
|
|
2010-10-25 18:38:37 +04:00
|
|
|
psmisc = callPackage ../os-specific/linux/psmisc { };
|
2007-12-11 14:47:23 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pstoedit = callPackage ../tools/graphics/pstoedit { };
|
2009-10-18 08:43:53 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pv = callPackage ../tools/misc/pv { };
|
2009-03-22 15:34:30 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pwgen = callPackage ../tools/security/pwgen { };
|
2007-06-28 13:53:12 +04:00
|
|
|
|
2012-02-04 13:30:53 +04:00
|
|
|
pydb = callPackage ../development/tools/pydb { };
|
2009-04-26 15:06:51 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pystringtemplate = callPackage ../development/python-modules/stringtemplate { };
|
2008-11-05 23:03:00 +03:00
|
|
|
|
2011-07-21 21:31:57 +04:00
|
|
|
pythonDBus = callPackage ../development/python-modules/dbus { };
|
2009-04-12 23:34:20 +04:00
|
|
|
|
2009-04-13 03:27:55 +04:00
|
|
|
pythonIRClib = builderDefsPackage (import ../development/python-modules/irclib) {
|
|
|
|
inherit python;
|
|
|
|
};
|
|
|
|
|
2009-04-12 23:34:20 +04:00
|
|
|
pythonSexy = builderDefsPackage (import ../development/python-modules/libsexy) {
|
|
|
|
inherit python libsexy pkgconfig libxml2 pygtk;
|
2009-04-17 17:48:22 +04:00
|
|
|
inherit (gtkLibs) pango gtk glib;
|
2009-04-12 23:34:20 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
openmpi = callPackage ../development/libraries/openmpi { };
|
2009-06-05 18:36:35 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
qdu = callPackage ../tools/misc/qdu { };
|
2010-05-27 23:44:12 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
qhull = callPackage ../development/libraries/qhull { };
|
2009-04-09 00:06:03 +04:00
|
|
|
|
2011-10-23 02:12:45 +04:00
|
|
|
qjoypad = callPackage ../tools/misc/qjoypad { };
|
|
|
|
|
2011-09-21 02:49:13 +04:00
|
|
|
qshowdiff = callPackage ../tools/text/qshowdiff { };
|
2010-03-15 17:26:52 +03:00
|
|
|
|
2011-02-19 19:04:34 +03:00
|
|
|
radvd = callPackage ../tools/networking/radvd { };
|
|
|
|
|
2012-01-05 03:05:51 +04:00
|
|
|
privateer = callPackage ../games/privateer { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rtmpdump = callPackage ../tools/video/rtmpdump { };
|
2010-05-01 01:46:55 +04:00
|
|
|
|
2010-12-21 19:26:34 +03:00
|
|
|
recutils = callPackage ../tools/misc/recutils { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
reiser4progs = callPackage ../tools/filesystems/reiser4progs { };
|
2009-12-04 18:39:49 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
reiserfsprogs = callPackage ../tools/filesystems/reiserfsprogs { };
|
2009-12-04 18:39:49 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
relfs = callPackage ../tools/filesystems/relfs {
|
2011-10-08 16:06:03 +04:00
|
|
|
inherit (gnome) gnome_vfs GConf;
|
2007-12-05 01:06:13 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
remind = callPackage ../tools/misc/remind { };
|
2009-02-26 01:44:08 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
replace = callPackage ../tools/text/replace { };
|
2007-07-15 15:59:33 +04:00
|
|
|
|
2011-09-05 12:32:55 +04:00
|
|
|
rdiff_backup = callPackage ../tools/backup/rdiff-backup { };
|
2007-09-09 00:45:23 +04:00
|
|
|
|
2010-10-18 13:43:17 +04:00
|
|
|
ripmime = callPackage ../tools/networking/ripmime {};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
rsnapshot = callPackage ../tools/backup/rsnapshot {
|
2008-03-07 12:33:51 +03:00
|
|
|
# For the `logger' command, we can use either `utillinux' or
|
|
|
|
# GNU Inetutils. The latter is more portable.
|
|
|
|
logger = inetutils;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rlwrap = callPackage ../tools/misc/rlwrap { };
|
2008-01-24 02:39:06 +03:00
|
|
|
|
2011-04-13 12:38:13 +04:00
|
|
|
rockbox_utility = callPackage ../tools/misc/rockbox-utility { };
|
|
|
|
|
2009-02-01 16:54:20 +03:00
|
|
|
rpPPPoE = builderDefsPackage (import ../tools/networking/rp-pppoe) {
|
|
|
|
inherit ppp;
|
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
rpm = callPackage ../tools/package-management/rpm {
|
2009-12-10 01:34:51 +03:00
|
|
|
db4 = db45;
|
2007-03-21 22:25:58 +03:00
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
rrdtool = callPackage ../tools/misc/rrdtool {
|
2009-03-25 22:13:24 +03:00
|
|
|
inherit (gtkLibs) pango;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rtorrent = callPackage ../tools/networking/p2p/rtorrent { };
|
2008-02-23 15:11:27 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rubber = callPackage ../tools/typesetting/rubber { };
|
2009-03-16 13:42:51 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rxp = callPackage ../tools/text/xml/rxp { };
|
2008-10-05 13:04:30 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rzip = callPackage ../tools/compression/rzip { };
|
2009-03-18 00:17:51 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
s3backer = callPackage ../tools/filesystems/s3backer { };
|
2009-12-04 18:51:02 +03:00
|
|
|
|
2011-08-13 15:49:23 +04:00
|
|
|
s3cmd = callPackage ../tools/networking/s3cmd { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
s3sync = callPackage ../tools/networking/s3sync { };
|
2010-03-09 18:12:15 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
sablotron = callPackage ../tools/text/xml/sablotron { };
|
2004-02-17 23:03:12 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
screen = callPackage ../tools/misc/screen { };
|
2005-12-26 03:51:24 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
scrot = callPackage ../tools/graphics/scrot { };
|
2009-09-03 02:56:33 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
seccure = callPackage ../tools/security/seccure/0.4.nix { };
|
2008-03-03 15:30:39 +03:00
|
|
|
|
2009-06-09 08:22:46 +04:00
|
|
|
setserial = builderDefsPackage (import ../tools/system/setserial) {
|
|
|
|
inherit groff;
|
|
|
|
};
|
|
|
|
|
2010-09-26 23:39:42 +04:00
|
|
|
sg3_utils = callPackage ../tools/system/sg3_utils { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
sharutils = callPackage ../tools/archivers/sharutils { };
|
2008-02-18 23:52:25 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
shebangfix = callPackage ../tools/misc/shebangfix { };
|
2007-11-14 22:07:38 +03:00
|
|
|
|
2011-06-07 20:15:05 +04:00
|
|
|
siege = callPackage ../tools/networking/siege {};
|
|
|
|
|
2011-08-03 00:06:09 +04:00
|
|
|
sleuthkit = callPackage ../tools/system/sleuthkit {};
|
2011-08-03 12:43:56 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
slimrat = callPackage ../tools/networking/slimrat {
|
2010-04-10 14:47:30 +04:00
|
|
|
inherit (perlPackages) WWWMechanize LWP;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
slsnif = callPackage ../tools/misc/slsnif { };
|
2008-08-21 15:07:29 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
smartmontools = callPackage ../tools/system/smartmontools { };
|
2007-10-18 17:05:43 +04:00
|
|
|
|
2011-12-28 01:35:50 +04:00
|
|
|
smbldaptools = callPackage ../tools/networking/smbldaptools {
|
|
|
|
inherit (perlPackages) NetLDAP CryptSmbHash DigestSHA1;
|
|
|
|
};
|
|
|
|
|
2011-02-19 12:56:35 +03:00
|
|
|
smbnetfs = callPackage ../tools/filesystems/smbnetfs {};
|
2007-10-18 17:05:43 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
fusesmb = callPackage ../tools/filesystems/fusesmb { };
|
2008-01-25 13:15:19 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
socat = callPackage ../tools/networking/socat { };
|
2008-02-03 14:03:54 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
sourceHighlight = callPackage ../tools/text/source-highlight { };
|
2010-04-30 16:23:26 +04:00
|
|
|
|
2009-11-23 15:21:34 +03:00
|
|
|
socat2pre = builderDefsPackage ../tools/networking/socat/2.0.0-b3.nix {
|
|
|
|
inherit fetchurl stdenv openssl;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
squashfsTools = callPackage ../tools/filesystems/squashfs { };
|
2009-12-04 18:39:49 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
sshfsFuse = callPackage ../tools/filesystems/sshfs-fuse { };
|
2009-12-04 18:39:49 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
sudo = callPackage ../tools/security/sudo { };
|
2007-06-20 03:55:02 +04:00
|
|
|
|
2011-08-22 19:24:24 +04:00
|
|
|
suidChroot = builderDefsPackage (import ../tools/system/suid-chroot) { };
|
|
|
|
|
|
|
|
super = callPackage ../tools/security/super { };
|
2009-07-12 12:10:51 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
ssmtp = callPackage ../tools/networking/ssmtp {
|
2007-11-08 20:48:52 +03:00
|
|
|
tlsSupport = true;
|
2007-08-08 02:22:31 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ssss = callPackage ../tools/security/ssss { };
|
2008-03-03 15:30:39 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
stun = callPackage ../tools/networking/stun { };
|
2009-10-18 08:43:45 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
stunnel = callPackage ../tools/networking/stunnel { };
|
2009-03-02 18:23:52 +03:00
|
|
|
|
2010-06-03 01:11:21 +04:00
|
|
|
su = shadow;
|
2007-01-11 18:22:59 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
swec = callPackage ../tools/networking/swec {
|
2010-01-24 22:07:16 +03:00
|
|
|
inherit (perlPackages) LWP URI HTMLParser HTTPServerSimple Parent;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
svnfs = callPackage ../tools/filesystems/svnfs { };
|
2010-04-16 19:56:31 +04:00
|
|
|
|
2010-11-28 12:46:51 +03:00
|
|
|
system_config_printer = callPackage ../tools/misc/system-config-printer {
|
|
|
|
libxml2 = libxml2Python;
|
|
|
|
};
|
2009-02-27 16:44:31 +03:00
|
|
|
|
2010-08-26 17:09:52 +04:00
|
|
|
sitecopy = callPackage ../tools/networking/sitecopy { };
|
2009-10-05 14:37:30 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
privoxy = callPackage ../tools/networking/privoxy {
|
2010-07-07 12:58:56 +04:00
|
|
|
autoconf = autoconf213;
|
2009-10-05 18:15:28 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
tcpdump = callPackage ../tools/networking/tcpdump { };
|
2007-01-16 17:35:08 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
tcng = callPackage ../tools/networking/tcng {
|
2012-02-18 03:47:00 +04:00
|
|
|
kernel = linux_2_6_27;
|
2009-03-17 17:18:45 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
telnet = callPackage ../tools/networking/telnet { };
|
2007-10-09 13:56:39 +04:00
|
|
|
|
2010-10-04 19:07:38 +04:00
|
|
|
texmacs = callPackage ../applications/editors/texmacs {
|
|
|
|
tex = texLive; /* tetex is also an option */
|
|
|
|
extraFonts = true;
|
2011-02-15 16:14:29 +03:00
|
|
|
guile = guile_1_8;
|
2010-10-04 19:07:38 +04:00
|
|
|
};
|
2010-02-13 22:22:16 +03:00
|
|
|
|
2010-11-28 15:38:35 +03:00
|
|
|
tmux = callPackage ../tools/misc/tmux { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
tor = callPackage ../tools/security/tor { };
|
2010-05-16 20:23:32 +04:00
|
|
|
|
2010-10-01 06:38:03 +04:00
|
|
|
torsocks = callPackage ../tools/security/tor/torsocks.nix { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ttf2pt1 = callPackage ../tools/misc/ttf2pt1 { };
|
2010-09-21 18:35:07 +04:00
|
|
|
ttf2pt1_cl_pdf = callPackage ../tools/misc/ttf2pt1 { };
|
2009-04-19 15:47:01 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ucl = callPackage ../development/libraries/ucl { };
|
2009-03-22 16:03:37 +03:00
|
|
|
|
2011-01-10 14:04:20 +03:00
|
|
|
udftools = callPackage ../tools/filesystems/udftools {};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
ufraw = callPackage ../applications/graphics/ufraw {
|
2009-10-19 16:50:45 +04:00
|
|
|
inherit (gnome) gtk;
|
|
|
|
};
|
|
|
|
|
2010-08-07 02:33:14 +04:00
|
|
|
unetbootin = callPackage ../tools/cd-dvd/unetbootin { };
|
|
|
|
|
2012-03-03 20:06:27 +04:00
|
|
|
unfs3 = callPackage ../servers/unfs3 { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
upx = callPackage ../tools/compression/upx { };
|
2010-10-04 13:49:25 +04:00
|
|
|
|
2010-09-26 23:39:35 +04:00
|
|
|
usbmuxd = callPackage ../tools/misc/usbmuxd {};
|
|
|
|
|
2010-09-20 12:40:30 +04:00
|
|
|
vacuum = callPackage ../applications/networking/instant-messengers/vacuum {};
|
2009-03-22 16:03:37 +03:00
|
|
|
|
2012-02-29 17:30:06 +04:00
|
|
|
vidalia = callPackage ../tools/security/vidalia { };
|
|
|
|
|
2009-10-24 23:58:07 +04:00
|
|
|
vbetool = builderDefsPackage ../tools/system/vbetool {
|
|
|
|
inherit pciutils libx86 zlib;
|
|
|
|
};
|
|
|
|
|
2011-01-12 16:39:17 +03:00
|
|
|
vde2 = callPackage ../tools/networking/vde2 { };
|
2011-02-24 14:25:16 +03:00
|
|
|
|
2010-11-26 01:01:14 +03:00
|
|
|
verilog = callPackage ../applications/science/electronics/verilog {};
|
|
|
|
|
2011-01-22 15:14:25 +03:00
|
|
|
vfdecrypt = callPackage ../tools/misc/vfdecrypt { };
|
|
|
|
|
2011-08-10 23:16:27 +04:00
|
|
|
vifm = callPackage ../applications/misc/vifm {};
|
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
viking = callPackage ../applications/misc/viking { };
|
2009-05-31 00:52:10 +04:00
|
|
|
|
2009-08-07 16:00:00 +04:00
|
|
|
vncrec = builderDefsPackage ../tools/video/vncrec {
|
|
|
|
inherit (xlibs) imake libX11 xproto gccmakedep libXt
|
|
|
|
libXmu libXaw libXext xextproto libSM libICE libXpm
|
|
|
|
libXp;
|
|
|
|
};
|
|
|
|
|
2011-03-06 19:07:37 +03:00
|
|
|
vorbisgain = callPackage ../tools/misc/vorbisgain { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
vpnc = callPackage ../tools/networking/vpnc { };
|
2008-02-11 00:54:01 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
vtun = callPackage ../tools/networking/vtun { };
|
2009-05-20 21:51:41 +04:00
|
|
|
|
2011-07-01 11:26:38 +04:00
|
|
|
welkin = callPackage ../tools/graphics/welkin {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
testdisk = callPackage ../tools/misc/testdisk { };
|
2007-09-12 19:49:28 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
htmlTidy = callPackage ../tools/text/html-tidy { };
|
2009-07-05 18:07:39 +04:00
|
|
|
|
2011-08-30 11:02:01 +04:00
|
|
|
tftp_hpa = callPackage ../tools/networking/tftp-hpa {};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
tigervnc = callPackage ../tools/admin/tigervnc {
|
2010-07-13 21:57:13 +04:00
|
|
|
fontDirectories = [ xorg.fontadobe75dpi xorg.fontmiscmisc xorg.fontcursormisc
|
|
|
|
xorg.fontbhlucidatypewriter75dpi ];
|
2010-07-13 02:15:36 +04:00
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
tightvnc = callPackage ../tools/admin/tightvnc {
|
2009-05-17 03:04:06 +04:00
|
|
|
fontDirectories = [ xorg.fontadobe75dpi xorg.fontmiscmisc xorg.fontcursormisc
|
|
|
|
xorg.fontbhlucidatypewriter75dpi ];
|
2006-04-18 22:46:36 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
time = callPackage ../tools/misc/time { };
|
2007-04-20 12:50:26 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
tm = callPackage ../tools/system/tm { };
|
2008-08-22 01:35:14 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
trang = callPackage ../tools/text/xml/trang { };
|
2005-08-21 17:59:04 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
tre = callPackage ../development/libraries/tre { };
|
2010-02-09 12:09:25 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ts = callPackage ../tools/system/ts { };
|
2008-08-22 01:35:14 +04:00
|
|
|
|
2012-03-05 13:40:36 +04:00
|
|
|
transfig = callPackage ../tools/graphics/transfig {
|
|
|
|
libpng = libpng12;
|
|
|
|
};
|
2005-08-21 23:46:16 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
truecrypt = callPackage ../applications/misc/truecrypt {
|
2009-10-02 12:00:30 +04:00
|
|
|
wxGUI = getConfig [ "truecrypt" "wxGUI" ] true;
|
2008-07-19 20:14:24 +04:00
|
|
|
};
|
|
|
|
|
2010-12-13 00:48:29 +03:00
|
|
|
ttmkfdir = callPackage ../tools/misc/ttmkfdir { };
|
2008-03-02 21:41:32 +03:00
|
|
|
|
2012-01-08 18:01:17 +04:00
|
|
|
unclutter = callPackage ../tools/misc/unclutter { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
unbound = callPackage ../tools/networking/unbound { };
|
2010-02-09 10:28:32 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
units = callPackage ../tools/misc/units { };
|
2007-06-20 19:15:51 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
unrar = callPackage ../tools/archivers/unrar { };
|
2007-06-24 19:34:44 +04:00
|
|
|
|
2010-10-23 18:55:14 +04:00
|
|
|
unarj = callPackage ../tools/archivers/unarj { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
unshield = callPackage ../tools/archivers/unshield { };
|
2007-05-28 21:09:30 +04:00
|
|
|
|
2011-08-01 08:53:21 +04:00
|
|
|
unzip = callPackage ../tools/archivers/unzip { };
|
2009-10-07 15:18:54 +04:00
|
|
|
|
2012-02-02 02:32:16 +04:00
|
|
|
unzipNLS = unzip.override { enableNLS = true; };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
uptimed = callPackage ../tools/system/uptimed { };
|
2009-09-16 11:31:16 +04:00
|
|
|
|
2011-03-31 15:10:00 +04:00
|
|
|
vlan = callPackage ../tools/networking/vlan { };
|
|
|
|
|
2011-04-21 00:55:46 +04:00
|
|
|
wakelan = callPackage ../tools/networking/wakelan { };
|
|
|
|
|
2011-06-29 13:53:35 +04:00
|
|
|
wavemon = callPackage ../tools/networking/wavemon { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
w3cCSSValidator = callPackage ../tools/misc/w3c-css-validator {
|
2010-01-24 18:39:42 +03:00
|
|
|
tomcat = tomcat6;
|
|
|
|
};
|
|
|
|
|
2010-08-29 16:27:41 +04:00
|
|
|
wdfs = callPackage ../tools/filesystems/wdfs { };
|
2008-07-08 03:24:48 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
wdiff = callPackage ../tools/text/wdiff { };
|
2010-03-25 14:51:55 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
webalizer = callPackage ../tools/networking/webalizer { };
|
2010-02-25 13:01:33 +03:00
|
|
|
|
2009-08-26 15:13:36 +04:00
|
|
|
webdruid = builderDefsPackage ../tools/admin/webdruid {
|
2009-09-23 00:16:38 +04:00
|
|
|
inherit zlib libpng freetype gd which
|
2009-08-26 15:13:36 +04:00
|
|
|
libxml2 geoip;
|
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
wget = callPackage ../tools/networking/wget {
|
2010-04-13 14:11:42 +04:00
|
|
|
inherit (perlPackages) LWP;
|
2006-07-18 00:35:02 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
which = callPackage ../tools/system/which { };
|
2006-01-27 23:51:41 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
wicd = callPackage ../tools/networking/wicd { };
|
2010-01-07 20:49:45 +03:00
|
|
|
|
2012-01-17 15:04:14 +04:00
|
|
|
wkhtmltopdf = callPackage ../tools/graphics/wkhtmltopdf { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
wv = callPackage ../tools/misc/wv { };
|
2007-08-18 12:32:12 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
wv2 = callPackage ../tools/misc/wv2 { };
|
2009-05-28 23:22:32 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
x11_ssh_askpass = callPackage ../tools/networking/x11-ssh-askpass { };
|
2007-04-02 17:46:56 +04:00
|
|
|
|
2010-12-28 20:25:17 +03:00
|
|
|
xbursttools = assert stdenv ? glibc; import ../tools/misc/xburst-tools {
|
2012-03-10 15:26:55 +04:00
|
|
|
inherit stdenv fetchgit autoconf automake confuse pkgconfig libusb libusb1;
|
2010-07-30 03:26:07 +04:00
|
|
|
# It needs a cross compiler for mipsel to build the firmware it will
|
|
|
|
# load into the Ben Nanonote
|
2010-08-19 16:37:10 +04:00
|
|
|
gccCross =
|
|
|
|
let
|
2010-07-30 03:26:07 +04:00
|
|
|
pkgsCross = (import ./all-packages.nix) {
|
|
|
|
inherit system;
|
|
|
|
inherit bootStdenv noSysDirs gccWithCC gccWithProfiling config;
|
|
|
|
# Ben Nanonote system
|
|
|
|
crossSystem = {
|
2010-08-03 01:40:34 +04:00
|
|
|
config = "mipsel-unknown-linux";
|
2010-07-30 03:26:07 +04:00
|
|
|
bigEndian = true;
|
|
|
|
arch = "mips";
|
|
|
|
float = "soft";
|
|
|
|
withTLS = true;
|
|
|
|
libc = "uclibc";
|
|
|
|
platform = {
|
|
|
|
name = "ben_nanonote";
|
|
|
|
kernelMajor = "2.6";
|
|
|
|
# It's not a bcm47xx processor, but for the headers this should work
|
|
|
|
kernelHeadersBaseConfig = "bcm47xx_defconfig";
|
|
|
|
kernelArch = "mips";
|
|
|
|
};
|
|
|
|
gcc = {
|
|
|
|
arch = "mips32";
|
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
2010-08-03 01:40:34 +04:00
|
|
|
in
|
2010-07-30 03:26:07 +04:00
|
|
|
pkgsCross.gccCrossStageStatic;
|
2010-07-30 03:25:42 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xclip = callPackage ../tools/misc/xclip { };
|
2007-09-22 01:40:23 +04:00
|
|
|
|
2010-11-28 19:37:48 +03:00
|
|
|
xdelta = callPackage ../tools/compression/xdelta { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xfsprogs = callPackage ../tools/filesystems/xfsprogs { };
|
2009-12-04 18:39:49 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
xmlroff = callPackage ../tools/typesetting/xmlroff {
|
2005-08-14 01:35:49 +04:00
|
|
|
inherit (gtkLibs) glib pango gtk;
|
|
|
|
inherit (gnome) libgnomeprint;
|
2005-08-13 22:12:10 +04:00
|
|
|
};
|
|
|
|
|
2010-08-20 14:07:35 +04:00
|
|
|
xmlstarlet = callPackage ../tools/text/xml/xmlstarlet { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xmlto = callPackage ../tools/typesetting/xmlto { };
|
2008-03-11 11:44:22 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xmltv = callPackage ../tools/misc/xmltv { };
|
2005-01-22 03:19:27 +03:00
|
|
|
|
2009-04-13 03:27:55 +04:00
|
|
|
xmpppy = builderDefsPackage (import ../development/python-modules/xmpppy) {
|
|
|
|
inherit python setuptools;
|
|
|
|
};
|
|
|
|
|
2011-01-27 23:12:28 +03:00
|
|
|
xorriso = callPackage ../tools/cd-dvd/xorriso { };
|
|
|
|
|
2012-02-28 04:07:08 +04:00
|
|
|
xpf = callPackage ../tools/text/xml/xpf {
|
|
|
|
libxml2 = libxml2Python;
|
|
|
|
};
|
2004-08-03 19:41:08 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xsel = callPackage ../tools/misc/xsel { };
|
2004-08-06 14:01:15 +04:00
|
|
|
|
2011-08-30 11:02:01 +04:00
|
|
|
xtreemfs = callPackage ../tools/filesystems/xtreemfs {};
|
|
|
|
|
2012-01-19 00:32:37 +04:00
|
|
|
youtubeDL = callPackage ../tools/misc/youtube-dl { };
|
|
|
|
|
2011-09-04 13:12:00 +04:00
|
|
|
zbar = callPackage ../tools/graphics/zbar {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
zdelta = callPackage ../tools/compression/zdelta { };
|
2005-12-19 01:14:31 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
zile = callPackage ../applications/editors/zile { };
|
2009-02-25 23:24:18 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
zip = callPackage ../tools/archivers/zip { };
|
2005-07-29 14:06:49 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
zsync = callPackage ../tools/compression/zsync { };
|
2006-07-13 18:54:24 +04:00
|
|
|
|
2011-03-22 15:55:55 +03:00
|
|
|
|
2003-11-03 21:21:30 +03:00
|
|
|
### SHELLS
|
|
|
|
|
2006-09-15 19:28:53 +04:00
|
|
|
|
2011-09-30 01:48:33 +04:00
|
|
|
bash = lowPrio (callPackage ../shells/bash {
|
2010-07-28 16:52:54 +04:00
|
|
|
texinfo = null;
|
2010-08-06 14:34:34 +04:00
|
|
|
});
|
2009-04-13 22:38:45 +04:00
|
|
|
|
2011-09-30 01:48:33 +04:00
|
|
|
bashInteractive = appendToName "interactive" (callPackage ../shells/bash {
|
2007-03-07 01:46:03 +03:00
|
|
|
interactive = true;
|
2007-04-26 17:02:30 +04:00
|
|
|
});
|
2007-03-07 01:46:03 +03:00
|
|
|
|
2011-07-22 02:02:01 +04:00
|
|
|
bashCompletion = callPackage ../shells/bash-completion { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dash = callPackage ../shells/dash { };
|
2010-06-01 21:05:29 +04:00
|
|
|
|
2011-03-28 16:40:53 +04:00
|
|
|
ipython = callPackage ../shells/ipython { };
|
2010-11-29 21:04:56 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
tcsh = callPackage ../shells/tcsh { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rush = callPackage ../shells/rush { };
|
2010-04-26 12:59:25 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
zsh = callPackage ../shells/zsh { };
|
2007-06-20 14:02:10 +04:00
|
|
|
|
2003-11-03 21:21:30 +03:00
|
|
|
|
2006-10-18 18:04:55 +04:00
|
|
|
### DEVELOPMENT / COMPILERS
|
2003-11-03 21:21:30 +03:00
|
|
|
|
2003-11-02 20:42:19 +03:00
|
|
|
|
2006-09-15 19:28:53 +04:00
|
|
|
abc =
|
|
|
|
abcPatchable [];
|
2006-08-05 15:02:17 +04:00
|
|
|
|
2008-06-19 02:48:34 +04:00
|
|
|
abcPatchable = patches :
|
2006-10-18 14:32:45 +04:00
|
|
|
import ../development/compilers/abc/default.nix {
|
2006-09-15 19:28:53 +04:00
|
|
|
inherit stdenv fetchurl patches jre apacheAnt;
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
javaCup = callPackage ../development/libraries/java/cup { };
|
2006-09-15 19:28:53 +04:00
|
|
|
};
|
2005-12-31 06:46:20 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
aspectj = callPackage ../development/compilers/aspectj { };
|
2004-09-25 23:32:23 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
bigloo = callPackage ../development/compilers/bigloo { };
|
2008-02-08 04:35:01 +03:00
|
|
|
|
2010-02-24 12:04:29 +03:00
|
|
|
ccl = builderDefsPackage ../development/compilers/ccl {};
|
|
|
|
|
2011-12-20 03:58:57 +04:00
|
|
|
clangUnwrapped = callPackage ../development/compilers/llvm/clang.nix {
|
2011-12-19 16:48:09 +04:00
|
|
|
# There is a bug in gcc-4.5 that prevents building a release build of
|
|
|
|
# clang-3.0
|
2011-12-20 03:58:57 +04:00
|
|
|
stdenv = if stdenv.isLinux
|
|
|
|
then (stdenvAdapters.overrideGCC stdenv gcc46)
|
|
|
|
else stdenv;
|
2011-10-20 00:57:18 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
clang = wrapClang clangUnwrapped;
|
2011-10-19 21:11:26 +04:00
|
|
|
|
|
|
|
#Use this instead of stdenv to build with clang
|
|
|
|
clangStdenv = stdenvAdapters.overrideGCC stdenv clang;
|
2010-06-13 01:52:39 +04:00
|
|
|
|
2010-12-25 18:13:07 +03:00
|
|
|
clean = callPackage ../development/compilers/clean { };
|
|
|
|
|
2010-11-08 11:58:50 +03:00
|
|
|
cmucl_binary = callPackage ../development/compilers/cmucl/binary.nix { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
dylan = callPackage ../development/compilers/gwydion-dylan {
|
2011-10-21 18:43:18 +04:00
|
|
|
dylan = callPackage ../development/compilers/gwydion-dylan/binary.nix { };
|
2004-01-30 13:10:06 +03:00
|
|
|
};
|
|
|
|
|
2011-01-18 20:36:25 +03:00
|
|
|
ecl = callPackage ../development/compilers/ecl { };
|
2010-01-20 08:41:18 +03:00
|
|
|
|
2010-09-17 23:52:50 +04:00
|
|
|
eql = callPackage ../development/compilers/eql {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
adobe_flex_sdk = callPackage ../development/compilers/adobe-flex-sdk { };
|
2009-04-06 17:07:21 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
fpc = callPackage ../development/compilers/fpc { };
|
2010-11-16 00:10:18 +03:00
|
|
|
fpc_2_4_0 = callPackage ../development/compilers/fpc/2.4.0.nix { };
|
2007-08-12 00:55:40 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gambit = callPackage ../development/compilers/gambit { };
|
2010-05-28 10:08:50 +04:00
|
|
|
|
2011-09-01 18:28:13 +04:00
|
|
|
gcc = gcc46;
|
2004-06-29 12:25:55 +04:00
|
|
|
|
2012-02-18 01:47:08 +04:00
|
|
|
gcc295 = wrapGCC (import ../development/compilers/gcc/2.95 {
|
2006-07-10 19:42:19 +04:00
|
|
|
inherit fetchurl stdenv noSysDirs;
|
|
|
|
});
|
|
|
|
|
2012-02-18 01:47:08 +04:00
|
|
|
gcc33 = wrapGCC (import ../development/compilers/gcc/3.3 {
|
2006-07-10 19:42:19 +04:00
|
|
|
inherit fetchurl stdenv noSysDirs;
|
|
|
|
});
|
|
|
|
|
2012-02-18 01:47:08 +04:00
|
|
|
gcc34 = wrapGCC (import ../development/compilers/gcc/3.4 {
|
2006-07-10 19:42:19 +04:00
|
|
|
inherit fetchurl stdenv noSysDirs;
|
|
|
|
});
|
|
|
|
|
2008-02-21 18:34:56 +03:00
|
|
|
# XXX: GCC 4.2 (and possibly others) misdetects `makeinfo' when
|
|
|
|
# using Texinfo >= 4.10, just because it uses a stupid regexp that
|
|
|
|
# expects a single digit after the dot. As a workaround, we feed
|
|
|
|
# GCC with Texinfo 4.9. Stupid bug, hackish workaround.
|
|
|
|
|
2012-02-18 01:47:08 +04:00
|
|
|
gcc40 = wrapGCC (makeOverridable (import ../development/compilers/gcc/4.0) {
|
2006-07-10 19:42:19 +04:00
|
|
|
inherit fetchurl stdenv noSysDirs;
|
2008-02-21 18:34:56 +03:00
|
|
|
texinfo = texinfo49;
|
2006-07-10 19:42:19 +04:00
|
|
|
profiledCompiler = true;
|
|
|
|
});
|
|
|
|
|
2012-02-18 01:47:08 +04:00
|
|
|
gcc41 = wrapGCC (makeOverridable (import ../development/compilers/gcc/4.1) {
|
2011-08-02 20:02:53 +04:00
|
|
|
inherit fetchurl noSysDirs gmp mpfr;
|
|
|
|
stdenv = overrideGCC stdenv gcc42;
|
2008-02-21 18:34:56 +03:00
|
|
|
texinfo = texinfo49;
|
2006-10-27 00:23:49 +04:00
|
|
|
profiledCompiler = false;
|
2007-11-15 18:19:58 +03:00
|
|
|
});
|
2007-08-19 03:58:30 +04:00
|
|
|
|
2012-02-18 01:47:08 +04:00
|
|
|
gcc42 = wrapGCC (makeOverridable (import ../development/compilers/gcc/4.2) {
|
2007-05-19 23:44:15 +04:00
|
|
|
inherit fetchurl stdenv noSysDirs;
|
2008-06-26 14:20:33 +04:00
|
|
|
profiledCompiler = false;
|
2008-10-07 21:34:35 +04:00
|
|
|
});
|
2008-06-27 22:26:19 +04:00
|
|
|
|
2012-02-18 01:47:08 +04:00
|
|
|
gcc43 = lowPrio (wrapGCC (makeOverridable (import ../development/compilers/gcc/4.3) {
|
- Removed all *NoCross expressions I dupilcated in nixpkgs, while maintaining
the cross compilation functionality.
- I renamed some expected stdenv.mkDerivation parameter attributes so we can
keep this branch properly updated from trunk. We agreed with Nicolas Pierron
doing a massive renaming, so all current buildInputs become hostInputs (input
as build for the host machine, in autotools terminology) , and
then buildInputs would mean "input as for the build machine".
By now, the specific "input as for the build machine" is specified through
buildNativeInputs. We should fix this in the merge to trunk.
- I made the generic stdenv understand the buildNativeInputs, otherwise if
we start changing nixpkgs expressions so they distinguish the current
buildInputs into buildInputs and buildNativeInputs, we could break even more
nixpkgs for other platforms.
- I changed the default result of mkDerivation so it becomes the derivation for
to be run in the build machine. This allows, without any special rewriting,
"fetchurl" derivations to be always results for the build machine to use
them.
- The change above implies that, for anyone wanting to cross-compile, has to
build the hostDrv of the wanted derivation. For example, after this commit,
the usual test of "nix-build -A bison.hostDrv arm.nix" works. I described
the contents of this arm.nix in r18398.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18471
2009-11-19 22:03:34 +03:00
|
|
|
inherit stdenv fetchurl texinfo gmp mpfr noSysDirs;
|
2009-02-02 00:44:56 +03:00
|
|
|
profiledCompiler = true;
|
2009-06-16 17:06:02 +04:00
|
|
|
}));
|
2009-02-02 00:44:56 +03:00
|
|
|
|
2012-02-18 01:47:08 +04:00
|
|
|
gcc43_realCross = makeOverridable (import ../development/compilers/gcc/4.3) {
|
2010-03-07 02:36:55 +03:00
|
|
|
inherit stdenv fetchurl texinfo gmp mpfr noSysDirs;
|
|
|
|
binutilsCross = binutilsCross;
|
|
|
|
libcCross = libcCross;
|
My first attempt at getting cross compilers in nixpkgs.
My idea is to provide special stdenv expressions that will contain in the path
additional cross compilers. As most expressions for programs accept a stdenv parameter,
we could substitute this parameter with the special stdenv, which will have a
generic builder that attempts the usual "--target=..." and can additionally
have an env variable like "cross" with the target architecture set.
So, finally we could have additional expressions like this:
bashRealArm = makeOverridable (import ../shells/bash) {
inherit fetchurl bison;
stdenv = stdenvCross "armv5tel-unknown-linux-gnueabi";
};
Meanwhile it does not work - I still cannot get the cross-gcc to build.
I think it does not fill the previous expressions with a lot of noise, so I
think it may be a good path to follow.
I only touched some files of the current stdenv: gcc-4.3, kernel headers
2.6.28, glibc 2.9, ...
I tried to use the gcc-cross-wrapper, that may be very outdated. Maybe I will
update it, or update the gcc-wrapper expression to make it fit the cross tools,
but meanwhile I even cannot build gcc, so I have not tested the wrapper.
This new idea on cross compiling is not similar to that of the
nixpkgs/branches/cross-compilation, which mostly added bare new expressions for
anything to be cross compiled, if I understood it correctly.
I cared not to break anything of the usual stdenv in all this work.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18343
2009-11-14 11:11:30 +03:00
|
|
|
profiledCompiler = false;
|
|
|
|
enableMultilib = true;
|
2009-11-15 08:39:22 +03:00
|
|
|
crossStageStatic = false;
|
2010-03-07 03:05:51 +03:00
|
|
|
cross = assert crossSystem != null; crossSystem;
|
2009-11-15 08:28:35 +03:00
|
|
|
};
|
|
|
|
|
2010-03-17 13:17:32 +03:00
|
|
|
gcc44_realCross = lib.addMetaAttrs { platforms = []; }
|
2012-02-18 01:47:08 +04:00
|
|
|
(makeOverridable (import ../development/compilers/gcc/4.4) {
|
2010-04-23 01:44:33 +04:00
|
|
|
inherit stdenv fetchurl texinfo gmp mpfr /* ppl cloogppl */ noSysDirs
|
2010-03-17 12:05:11 +03:00
|
|
|
gettext which;
|
|
|
|
binutilsCross = binutilsCross;
|
|
|
|
libcCross = libcCross;
|
|
|
|
profiledCompiler = false;
|
|
|
|
enableMultilib = false;
|
|
|
|
crossStageStatic = false;
|
|
|
|
cross = assert crossSystem != null; crossSystem;
|
|
|
|
});
|
2009-11-30 02:27:35 +03:00
|
|
|
|
2010-08-08 01:31:16 +04:00
|
|
|
gcc45 = gcc45_real;
|
2010-06-15 15:55:19 +04:00
|
|
|
|
2011-04-01 01:51:39 +04:00
|
|
|
gcc46 = gcc46_real;
|
|
|
|
|
2010-04-30 23:12:59 +04:00
|
|
|
gcc45_realCross = lib.addMetaAttrs { platforms = []; }
|
2012-02-18 01:47:08 +04:00
|
|
|
(makeOverridable (import ../development/compilers/gcc/4.5) {
|
2010-04-30 23:12:59 +04:00
|
|
|
inherit fetchurl stdenv texinfo gmp mpfr mpc libelf zlib
|
|
|
|
ppl cloogppl gettext which noSysDirs;
|
|
|
|
binutilsCross = binutilsCross;
|
|
|
|
libcCross = libcCross;
|
|
|
|
profiledCompiler = false;
|
|
|
|
enableMultilib = false;
|
|
|
|
crossStageStatic = false;
|
|
|
|
cross = assert crossSystem != null; crossSystem;
|
|
|
|
});
|
|
|
|
|
2011-04-01 01:56:57 +04:00
|
|
|
gcc46_realCross = lib.addMetaAttrs { platforms = []; }
|
2012-02-18 01:47:08 +04:00
|
|
|
(makeOverridable (import ../development/compilers/gcc/4.6) {
|
2011-04-01 01:56:57 +04:00
|
|
|
inherit fetchurl stdenv texinfo gmp mpfr mpc libelf zlib
|
2011-12-14 18:31:56 +04:00
|
|
|
cloog ppl gettext which noSysDirs;
|
2011-04-01 01:56:57 +04:00
|
|
|
binutilsCross = binutilsCross;
|
|
|
|
libcCross = libcCross;
|
|
|
|
profiledCompiler = false;
|
|
|
|
enableMultilib = false;
|
|
|
|
crossStageStatic = false;
|
|
|
|
cross = assert crossSystem != null; crossSystem;
|
|
|
|
});
|
|
|
|
|
2012-03-07 20:01:12 +04:00
|
|
|
gcc_realCross = gcc46_realCross;
|
2010-05-06 22:22:51 +04:00
|
|
|
|
|
|
|
gccCrossStageStatic = let
|
|
|
|
isMingw = (stdenv.cross.libc == "msvcrt");
|
2010-05-06 23:19:22 +04:00
|
|
|
libcCross1 = if isMingw then windows.mingw_headers1 else null;
|
2010-05-06 22:22:51 +04:00
|
|
|
in
|
|
|
|
wrapGCCCross {
|
|
|
|
gcc = forceBuildDrv (lib.addMetaAttrs { platforms = []; } (
|
|
|
|
gcc_realCross.override {
|
|
|
|
crossStageStatic = true;
|
|
|
|
langCC = false;
|
|
|
|
libcCross = libcCross1;
|
|
|
|
enableShared = false;
|
|
|
|
}));
|
|
|
|
libc = libcCross1;
|
|
|
|
binutils = binutilsCross;
|
|
|
|
cross = assert crossSystem != null; crossSystem;
|
|
|
|
};
|
|
|
|
|
|
|
|
# Only needed for mingw builds
|
|
|
|
gccCrossMingw2 = wrapGCCCross {
|
|
|
|
gcc = gccCrossStageStatic.gcc;
|
2010-05-06 23:19:22 +04:00
|
|
|
libc = windows.mingw_headers2;
|
2010-03-07 02:36:55 +03:00
|
|
|
binutils = binutilsCross;
|
2010-03-07 03:05:51 +03:00
|
|
|
cross = assert crossSystem != null; crossSystem;
|
My first attempt at getting cross compilers in nixpkgs.
My idea is to provide special stdenv expressions that will contain in the path
additional cross compilers. As most expressions for programs accept a stdenv parameter,
we could substitute this parameter with the special stdenv, which will have a
generic builder that attempts the usual "--target=..." and can additionally
have an env variable like "cross" with the target architecture set.
So, finally we could have additional expressions like this:
bashRealArm = makeOverridable (import ../shells/bash) {
inherit fetchurl bison;
stdenv = stdenvCross "armv5tel-unknown-linux-gnueabi";
};
Meanwhile it does not work - I still cannot get the cross-gcc to build.
I think it does not fill the previous expressions with a lot of noise, so I
think it may be a good path to follow.
I only touched some files of the current stdenv: gcc-4.3, kernel headers
2.6.28, glibc 2.9, ...
I tried to use the gcc-cross-wrapper, that may be very outdated. Maybe I will
update it, or update the gcc-wrapper expression to make it fit the cross tools,
but meanwhile I even cannot build gcc, so I have not tested the wrapper.
This new idea on cross compiling is not similar to that of the
nixpkgs/branches/cross-compilation, which mostly added bare new expressions for
anything to be cross compiled, if I understood it correctly.
I cared not to break anything of the usual stdenv in all this work.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18343
2009-11-14 11:11:30 +03:00
|
|
|
};
|
|
|
|
|
2010-03-07 02:36:55 +03:00
|
|
|
gccCrossStageFinal = wrapGCCCross {
|
2010-05-20 01:32:19 +04:00
|
|
|
gcc = forceBuildDrv (gcc_realCross.override {
|
|
|
|
libpthreadCross =
|
|
|
|
# FIXME: Don't explicitly refer to `i586-pc-gnu'.
|
|
|
|
if crossSystem != null && crossSystem.config == "i586-pc-gnu"
|
2011-11-02 02:10:51 +04:00
|
|
|
then gnu.libpthreadCross
|
2010-05-20 01:32:19 +04:00
|
|
|
else null;
|
|
|
|
});
|
2010-03-07 02:36:55 +03:00
|
|
|
libc = libcCross;
|
|
|
|
binutils = binutilsCross;
|
2010-03-07 03:05:51 +03:00
|
|
|
cross = assert crossSystem != null; crossSystem;
|
2009-11-15 08:28:35 +03:00
|
|
|
};
|
My first attempt at getting cross compilers in nixpkgs.
My idea is to provide special stdenv expressions that will contain in the path
additional cross compilers. As most expressions for programs accept a stdenv parameter,
we could substitute this parameter with the special stdenv, which will have a
generic builder that attempts the usual "--target=..." and can additionally
have an env variable like "cross" with the target architecture set.
So, finally we could have additional expressions like this:
bashRealArm = makeOverridable (import ../shells/bash) {
inherit fetchurl bison;
stdenv = stdenvCross "armv5tel-unknown-linux-gnueabi";
};
Meanwhile it does not work - I still cannot get the cross-gcc to build.
I think it does not fill the previous expressions with a lot of noise, so I
think it may be a good path to follow.
I only touched some files of the current stdenv: gcc-4.3, kernel headers
2.6.28, glibc 2.9, ...
I tried to use the gcc-cross-wrapper, that may be very outdated. Maybe I will
update it, or update the gcc-wrapper expression to make it fit the cross tools,
but meanwhile I even cannot build gcc, so I have not tested the wrapper.
This new idea on cross compiling is not similar to that of the
nixpkgs/branches/cross-compilation, which mostly added bare new expressions for
anything to be cross compiled, if I understood it correctly.
I cared not to break anything of the usual stdenv in all this work.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18343
2009-11-14 11:11:30 +03:00
|
|
|
|
2009-11-30 02:27:35 +03:00
|
|
|
gcc43_multi = lowPrio (wrapGCCWith (import ../build-support/gcc-wrapper) glibc_multi (gcc43.gcc.override {
|
2009-04-02 23:55:57 +04:00
|
|
|
stdenv = overrideGCC stdenv (wrapGCCWith (import ../build-support/gcc-wrapper) glibc_multi gcc);
|
2008-06-27 22:26:19 +04:00
|
|
|
profiledCompiler = false;
|
|
|
|
enableMultilib = true;
|
2008-06-26 14:20:33 +04:00
|
|
|
}));
|
|
|
|
|
2012-02-18 01:47:08 +04:00
|
|
|
gcc44 = lowPrio (wrapGCC (makeOverridable (import ../development/compilers/gcc/4.4) {
|
2010-01-19 20:10:53 +03:00
|
|
|
inherit fetchurl stdenv texinfo gmp mpfr /* ppl cloogppl */
|
2009-07-27 19:40:01 +04:00
|
|
|
gettext which noSysDirs;
|
2009-07-03 22:54:28 +04:00
|
|
|
profiledCompiler = true;
|
2009-09-23 22:33:40 +04:00
|
|
|
}));
|
2009-07-03 22:54:28 +04:00
|
|
|
|
2012-02-18 01:47:08 +04:00
|
|
|
gcc45_real = lowPrio (wrapGCC (makeOverridable (import ../development/compilers/gcc/4.5) {
|
2010-05-25 23:38:18 +04:00
|
|
|
inherit fetchurl stdenv texinfo gmp mpfr mpc libelf zlib perl
|
2010-04-28 16:37:11 +04:00
|
|
|
ppl cloogppl
|
|
|
|
gettext which noSysDirs;
|
2010-08-05 22:40:58 +04:00
|
|
|
# bootstrapping a profiled compiler does not work in the sheevaplug:
|
|
|
|
# http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43944
|
|
|
|
profiledCompiler = if stdenv.system == "armv5tel-linux" then false else true;
|
2011-11-13 03:55:41 +04:00
|
|
|
|
|
|
|
# When building `gcc.hostDrv' (a "Canadian cross", with host == target
|
|
|
|
# and host != build), `cross' must be null but the cross-libc must still
|
|
|
|
# be passed.
|
|
|
|
cross = null;
|
|
|
|
libcCross = if crossSystem != null then libcCross else null;
|
|
|
|
libpthreadCross =
|
|
|
|
if crossSystem != null && crossSystem.config == "i586-pc-gnu"
|
|
|
|
then gnu.libpthreadCross
|
|
|
|
else null;
|
2010-04-28 16:37:11 +04:00
|
|
|
}));
|
|
|
|
|
2011-03-23 17:51:17 +03:00
|
|
|
# A non-stripped version of GCC.
|
2012-02-18 01:47:08 +04:00
|
|
|
gcc45_debug = lowPrio (wrapGCC (callPackage ../development/compilers/gcc/4.5 {
|
2011-03-23 17:51:17 +03:00
|
|
|
stripped = false;
|
|
|
|
|
|
|
|
inherit noSysDirs;
|
|
|
|
|
|
|
|
# bootstrapping a profiled compiler does not work in the sheevaplug:
|
|
|
|
# http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43944
|
|
|
|
profiledCompiler = if stdenv.system == "armv5tel-linux" then false else true;
|
|
|
|
}));
|
|
|
|
|
2012-02-18 01:47:08 +04:00
|
|
|
gcc46_real = lowPrio (wrapGCC (callPackage ../development/compilers/gcc/4.6 {
|
2011-04-06 16:52:29 +04:00
|
|
|
inherit noSysDirs;
|
|
|
|
|
2011-04-01 01:51:39 +04:00
|
|
|
# bootstrapping a profiled compiler does not work in the sheevaplug:
|
|
|
|
# http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43944
|
|
|
|
profiledCompiler = if stdenv.system == "armv5tel-linux" then false else true;
|
2012-02-27 21:22:30 +04:00
|
|
|
|
|
|
|
# When building `gcc.hostDrv' (a "Canadian cross", with host == target
|
|
|
|
# and host != build), `cross' must be null but the cross-libc must still
|
|
|
|
# be passed.
|
|
|
|
cross = null;
|
|
|
|
libcCross = if crossSystem != null then libcCross else null;
|
|
|
|
libpthreadCross =
|
|
|
|
if crossSystem != null && crossSystem.config == "i586-pc-gnu"
|
|
|
|
then gnu.libpthreadCross
|
|
|
|
else null;
|
2011-04-01 01:51:39 +04:00
|
|
|
}));
|
|
|
|
|
2011-04-06 16:52:33 +04:00
|
|
|
# A non-stripped version of GCC.
|
2012-02-18 01:47:08 +04:00
|
|
|
gcc46_debug = lowPrio (wrapGCC (callPackage ../development/compilers/gcc/4.6 {
|
2011-04-06 16:52:33 +04:00
|
|
|
stripped = false;
|
|
|
|
|
|
|
|
inherit noSysDirs;
|
|
|
|
cross = null;
|
|
|
|
libcCross = null;
|
|
|
|
binutilsCross = null;
|
|
|
|
}));
|
|
|
|
|
2012-03-08 19:36:50 +04:00
|
|
|
gcc47 = lowPrio (wrapGCC (lib.overrideDerivation gcc46_debug.gcc (a: {
|
|
|
|
name = "gcc-debug-4.7.0rc20120302";
|
|
|
|
src = fetchurl {
|
|
|
|
url = "ftp://gcc.gnu.org/pub/gcc/snapshots/4.7.0-RC-20120302/gcc-4.7.0-RC-20120302.tar.bz2";
|
|
|
|
sha256 = "13clix3cqf93rmkgmb9izqz0ld0h0xrgpirsjr0fs0f7c86c935l";
|
|
|
|
};
|
|
|
|
|
|
|
|
configureFlags = a.configureFlags
|
|
|
|
# This flag replaces `no-sys-dirs.patch'.
|
2012-03-11 21:35:45 +04:00
|
|
|
+ (lib.optionalString (stdenv ? glibc)
|
|
|
|
" --with-native-system-header-dir=${stdenv.glibc}/include");
|
2012-03-08 19:36:50 +04:00
|
|
|
|
|
|
|
patches = [];
|
|
|
|
})));
|
|
|
|
|
2009-11-27 20:40:56 +03:00
|
|
|
gccApple =
|
2012-02-18 01:47:08 +04:00
|
|
|
wrapGCC ( (if stdenv.system == "i686-darwin" then import ../development/compilers/gcc/4.2-apple32 else import ../development/compilers/gcc/4.2-apple64) {
|
2009-11-27 13:56:07 +03:00
|
|
|
inherit fetchurl stdenv noSysDirs;
|
|
|
|
profiledCompiler = true;
|
2012-02-18 01:47:08 +04:00
|
|
|
});
|
2006-09-15 19:28:53 +04:00
|
|
|
|
2008-03-04 19:20:11 +03:00
|
|
|
gccupc40 = wrapGCCUPC (import ../development/compilers/gcc-upc-4.0 {
|
|
|
|
inherit fetchurl stdenv bison autoconf gnum4 noSysDirs;
|
|
|
|
texinfo = texinfo49;
|
|
|
|
});
|
|
|
|
|
2012-03-07 02:27:14 +04:00
|
|
|
gfortran = gfortran46;
|
2009-04-09 19:24:33 +04:00
|
|
|
|
|
|
|
gfortran40 = wrapGCC (gcc40.gcc.override {
|
|
|
|
langFortran = true;
|
|
|
|
langCC = false;
|
|
|
|
inherit gmp mpfr;
|
|
|
|
});
|
|
|
|
|
|
|
|
gfortran41 = wrapGCC (gcc41.gcc.override {
|
|
|
|
name = "gfortran";
|
|
|
|
langFortran = true;
|
|
|
|
langCC = false;
|
|
|
|
langC = false;
|
|
|
|
inherit gmp mpfr;
|
|
|
|
});
|
|
|
|
|
|
|
|
gfortran42 = wrapGCC (gcc42.gcc.override {
|
|
|
|
name = "gfortran";
|
|
|
|
langFortran = true;
|
|
|
|
langCC = false;
|
|
|
|
langC = false;
|
|
|
|
inherit gmp mpfr;
|
|
|
|
});
|
|
|
|
|
2009-11-30 02:27:35 +03:00
|
|
|
gfortran43 = wrapGCC (gcc43.gcc.override {
|
2009-04-09 19:24:33 +04:00
|
|
|
name = "gfortran";
|
|
|
|
langFortran = true;
|
|
|
|
langCC = false;
|
|
|
|
langC = false;
|
|
|
|
profiledCompiler = false;
|
|
|
|
});
|
|
|
|
|
2010-06-15 16:11:40 +04:00
|
|
|
gfortran44 = wrapGCC (gcc44.gcc.override {
|
|
|
|
name = "gfortran";
|
|
|
|
langFortran = true;
|
|
|
|
langCC = false;
|
|
|
|
langC = false;
|
|
|
|
profiledCompiler = false;
|
|
|
|
});
|
|
|
|
|
|
|
|
gfortran45 = wrapGCC (gcc45_real.gcc.override {
|
2009-07-25 02:19:07 +04:00
|
|
|
name = "gfortran";
|
|
|
|
langFortran = true;
|
|
|
|
langCC = false;
|
|
|
|
langC = false;
|
|
|
|
profiledCompiler = false;
|
|
|
|
});
|
|
|
|
|
2011-04-01 01:59:38 +04:00
|
|
|
gfortran46 = wrapGCC (gcc46_real.gcc.override {
|
|
|
|
name = "gfortran";
|
|
|
|
langFortran = true;
|
|
|
|
langCC = false;
|
|
|
|
langC = false;
|
|
|
|
profiledCompiler = false;
|
|
|
|
});
|
|
|
|
|
2010-05-26 18:53:09 +04:00
|
|
|
gcj = gcj45;
|
2009-05-10 13:11:41 +04:00
|
|
|
|
2010-06-15 16:11:40 +04:00
|
|
|
gcj44 = wrapGCC (gcc44.gcc.override {
|
2009-07-03 22:54:28 +04:00
|
|
|
name = "gcj";
|
|
|
|
langJava = true;
|
|
|
|
langFortran = false;
|
|
|
|
langCC = true;
|
2009-07-27 19:40:01 +04:00
|
|
|
langC = false;
|
2009-07-03 22:54:28 +04:00
|
|
|
profiledCompiler = false;
|
2009-07-28 12:11:10 +04:00
|
|
|
inherit zip unzip zlib boehmgc gettext pkgconfig;
|
|
|
|
inherit (gtkLibs) gtk;
|
2009-07-28 13:23:40 +04:00
|
|
|
inherit (gnome) libart_lgpl;
|
2009-11-06 00:43:00 +03:00
|
|
|
inherit (xlibs) libX11 libXt libSM libICE libXtst libXi libXrender
|
2009-07-30 12:32:43 +04:00
|
|
|
libXrandr xproto renderproto xextproto inputproto randrproto;
|
2009-07-03 22:54:28 +04:00
|
|
|
});
|
|
|
|
|
2010-04-28 16:37:11 +04:00
|
|
|
gcj45 = wrapGCC (gcc45.gcc.override {
|
|
|
|
name = "gcj";
|
|
|
|
langJava = true;
|
|
|
|
langFortran = false;
|
|
|
|
langCC = true;
|
|
|
|
langC = false;
|
|
|
|
profiledCompiler = false;
|
2010-05-25 23:38:13 +04:00
|
|
|
inherit zip unzip zlib boehmgc gettext pkgconfig perl;
|
2010-04-28 16:37:11 +04:00
|
|
|
inherit (gtkLibs) gtk;
|
|
|
|
inherit (gnome) libart_lgpl;
|
|
|
|
inherit (xlibs) libX11 libXt libSM libICE libXtst libXi libXrender
|
|
|
|
libXrandr xproto renderproto xextproto inputproto randrproto;
|
|
|
|
});
|
|
|
|
|
2011-04-01 02:04:08 +04:00
|
|
|
gcj46 = wrapGCC (gcc46.gcc.override {
|
|
|
|
name = "gcj";
|
|
|
|
langJava = true;
|
|
|
|
langFortran = false;
|
|
|
|
langCC = true;
|
|
|
|
langC = false;
|
|
|
|
profiledCompiler = false;
|
|
|
|
inherit zip unzip zlib boehmgc gettext pkgconfig perl;
|
|
|
|
inherit (gtkLibs) gtk;
|
|
|
|
inherit (gnome) libart_lgpl;
|
|
|
|
inherit (xlibs) libX11 libXt libSM libICE libXtst libXi libXrender
|
|
|
|
libXrandr xproto renderproto xextproto inputproto randrproto;
|
|
|
|
});
|
|
|
|
|
2010-06-15 16:11:40 +04:00
|
|
|
gnat = gnat45;
|
|
|
|
|
|
|
|
gnat44 = wrapGCC (gcc44.gcc.override {
|
|
|
|
name = "gnat";
|
|
|
|
langCC = false;
|
|
|
|
langC = true;
|
|
|
|
langAda = true;
|
|
|
|
profiledCompiler = false;
|
|
|
|
inherit gnatboot;
|
|
|
|
# We can't use the ppl stuff, because we would have
|
|
|
|
# libstdc++ problems.
|
|
|
|
cloogppl = null;
|
|
|
|
ppl = null;
|
|
|
|
});
|
2009-12-21 10:49:31 +03:00
|
|
|
|
2010-06-15 16:11:40 +04:00
|
|
|
gnat45 = wrapGCC (gcc45_real.gcc.override {
|
2009-12-21 10:49:31 +03:00
|
|
|
name = "gnat";
|
|
|
|
langCC = false;
|
|
|
|
langC = true;
|
|
|
|
langAda = true;
|
|
|
|
profiledCompiler = false;
|
|
|
|
inherit gnatboot;
|
|
|
|
# We can't use the ppl stuff, because we would have
|
|
|
|
# libstdc++ problems.
|
|
|
|
cloogppl = null;
|
|
|
|
ppl = null;
|
|
|
|
});
|
|
|
|
|
2011-04-01 02:20:11 +04:00
|
|
|
gnat46 = wrapGCC (gcc46_real.gcc.override {
|
|
|
|
name = "gnat";
|
|
|
|
langCC = false;
|
|
|
|
langC = true;
|
|
|
|
langAda = true;
|
|
|
|
profiledCompiler = false;
|
|
|
|
gnatboot = gnat45;
|
|
|
|
# We can't use the ppl stuff, because we would have
|
|
|
|
# libstdc++ problems.
|
|
|
|
ppl = null;
|
|
|
|
cloog = null;
|
|
|
|
});
|
|
|
|
|
2010-01-17 00:32:44 +03:00
|
|
|
gnatboot = wrapGCC (import ../development/compilers/gnatboot {
|
2009-12-21 10:49:31 +03:00
|
|
|
inherit fetchurl stdenv;
|
|
|
|
});
|
|
|
|
|
2011-04-02 19:21:36 +04:00
|
|
|
gccgo = gccgo46;
|
|
|
|
|
|
|
|
gccgo46 = wrapGCC (gcc46_real.gcc.override {
|
|
|
|
name = "gccgo";
|
|
|
|
langCC = true; #required for go
|
|
|
|
langC = true;
|
|
|
|
langGo = true;
|
|
|
|
});
|
|
|
|
|
2012-02-18 01:47:08 +04:00
|
|
|
ghdl = wrapGCC (import ../development/compilers/gcc/4.3 {
|
2009-12-22 02:02:06 +03:00
|
|
|
inherit stdenv fetchurl texinfo gmp mpfr noSysDirs gnat;
|
2010-01-15 02:03:31 +03:00
|
|
|
name = "ghdl";
|
2009-12-22 02:02:06 +03:00
|
|
|
langVhdl = true;
|
|
|
|
langCC = false;
|
|
|
|
langC = false;
|
|
|
|
profiledCompiler = false;
|
|
|
|
enableMultilib = false;
|
|
|
|
});
|
|
|
|
|
2010-01-16 02:22:28 +03:00
|
|
|
# Not officially supported version for ghdl
|
2012-02-18 01:47:08 +04:00
|
|
|
ghdl_gcc44 = lowPrio (wrapGCC (import ../development/compilers/gcc/4.4 {
|
2010-01-16 02:22:28 +03:00
|
|
|
inherit stdenv fetchurl texinfo gmp mpfr noSysDirs gnat gettext which
|
|
|
|
ppl cloogppl;
|
|
|
|
name = "ghdl";
|
|
|
|
langVhdl = true;
|
|
|
|
langCC = false;
|
|
|
|
langC = false;
|
|
|
|
profiledCompiler = false;
|
|
|
|
enableMultilib = false;
|
|
|
|
}));
|
|
|
|
|
2009-11-06 00:08:53 +03:00
|
|
|
gcl = builderDefsPackage ../development/compilers/gcl {
|
2010-07-26 17:41:09 +04:00
|
|
|
inherit mpfr m4 binutils fetchcvs emacs zlib which
|
2010-07-09 08:24:31 +04:00
|
|
|
gmp texinfo;
|
2009-11-27 20:40:56 +03:00
|
|
|
inherit (xlibs) libX11 xproto inputproto libXi
|
2009-11-06 10:39:59 +03:00
|
|
|
libXext xextproto libXt libXaw libXmu;
|
2010-07-06 20:48:03 +04:00
|
|
|
inherit stdenv;
|
2010-07-09 08:24:31 +04:00
|
|
|
texLive = texLiveAggregationFun {
|
|
|
|
paths = [
|
|
|
|
texLive texLiveExtra
|
|
|
|
];
|
|
|
|
};
|
2009-11-06 00:08:53 +03:00
|
|
|
};
|
|
|
|
|
2009-09-17 15:45:20 +04:00
|
|
|
# GHC
|
|
|
|
|
|
|
|
# GHC binaries are around for bootstrapping purposes
|
|
|
|
|
2010-04-27 22:21:07 +04:00
|
|
|
# If we'd want to reactivate the 6.6 and 6.8 series of ghc, we'd
|
|
|
|
# need to reenable an old binary such as this.
|
2009-12-11 16:58:41 +03:00
|
|
|
/*
|
2009-04-17 02:06:33 +04:00
|
|
|
ghc642Binary = lowPrio (import ../development/compilers/ghc/6.4.2-binary.nix {
|
|
|
|
inherit fetchurl stdenv ncurses gmp;
|
2009-12-11 16:58:36 +03:00
|
|
|
readline = if stdenv.system == "i686-linux" then readline4 else readline5;
|
2009-04-17 02:06:33 +04:00
|
|
|
perl = perl58;
|
|
|
|
});
|
2009-12-11 16:58:41 +03:00
|
|
|
*/
|
2007-10-19 17:24:29 +04:00
|
|
|
|
2012-01-18 22:43:34 +04:00
|
|
|
ghc6101Binary = lowPrio (callPackage ../development/compilers/ghc/6.10.1-binary.nix {
|
|
|
|
gmp = gmp4;
|
2009-04-17 23:43:05 +04:00
|
|
|
});
|
2008-06-04 13:42:25 +04:00
|
|
|
|
2012-01-18 22:43:34 +04:00
|
|
|
ghc6102Binary = lowPrio (callPackage ../development/compilers/ghc/6.10.2-binary.nix {
|
|
|
|
gmp = gmp4;
|
2008-07-25 18:21:54 +04:00
|
|
|
});
|
2008-07-21 18:43:33 +04:00
|
|
|
|
2012-01-18 22:43:34 +04:00
|
|
|
ghc6121Binary = lowPrio (callPackage ../development/compilers/ghc/6.12.1-binary.nix {
|
|
|
|
gmp = gmp4;
|
2011-08-05 12:52:35 +04:00
|
|
|
});
|
|
|
|
|
2012-01-18 22:43:34 +04:00
|
|
|
ghc704Binary = lowPrio (callPackage ../development/compilers/ghc/7.0.4-binary.nix {
|
|
|
|
gmp = gmp4;
|
2011-08-29 05:20:12 +04:00
|
|
|
});
|
2011-08-05 12:52:35 +04:00
|
|
|
|
2009-09-17 15:45:20 +04:00
|
|
|
# For several compiler versions, we export a large set of Haskell-related
|
|
|
|
# packages.
|
|
|
|
|
2010-04-27 22:21:07 +04:00
|
|
|
# This should point to the current default version.
|
2011-08-05 12:52:35 +04:00
|
|
|
haskellPackages = haskellPackages_ghc704;
|
2009-04-18 16:47:11 +04:00
|
|
|
|
2011-08-09 15:10:24 +04:00
|
|
|
# NOTE (recurseIntoAttrs): After discussion, we originally decided to
|
|
|
|
# enable it for all GHC versions. However, this is getting too much,
|
|
|
|
# particularly in connection with Hydra builds for all these packages.
|
|
|
|
# So we enable it for selected versions only.
|
2009-05-11 01:04:58 +04:00
|
|
|
|
2010-04-27 22:21:07 +04:00
|
|
|
# Helper functions to abstract away from repetitive instantiations.
|
2011-08-05 12:52:35 +04:00
|
|
|
haskellPackagesFun =
|
2011-08-09 15:18:31 +04:00
|
|
|
ghcPath : ghcBinary : prefFun : profExplicit : profDefault : modifyPrio :
|
2011-08-09 15:10:24 +04:00
|
|
|
import ./haskell-packages.nix {
|
2011-08-05 12:52:35 +04:00
|
|
|
inherit pkgs newScope modifyPrio prefFun;
|
2011-08-09 15:18:31 +04:00
|
|
|
enableLibraryProfiling =
|
|
|
|
if profExplicit then profDefault
|
|
|
|
else getConfig [ "cabal" "libraryProfiling" ] profDefault;
|
2011-08-05 12:52:35 +04:00
|
|
|
ghc = callPackage ghcPath { ghc = ghcBinary; };
|
2011-08-09 15:10:24 +04:00
|
|
|
};
|
2009-10-15 16:49:37 +04:00
|
|
|
|
2010-04-27 22:21:07 +04:00
|
|
|
# Currently active GHC versions.
|
2010-05-01 15:23:39 +04:00
|
|
|
haskellPackages_ghc6104 =
|
2011-08-09 15:10:24 +04:00
|
|
|
recurseIntoAttrs
|
|
|
|
(haskellPackagesFun ../development/compilers/ghc/6.10.4.nix
|
2011-08-09 18:32:20 +04:00
|
|
|
ghc6101Binary (x : x.ghc6104Prefs) false false lowPrio);
|
2010-04-27 22:21:07 +04:00
|
|
|
|
2010-07-22 22:47:59 +04:00
|
|
|
haskellPackages_ghc6121 =
|
2011-08-05 12:52:35 +04:00
|
|
|
haskellPackagesFun ../development/compilers/ghc/6.12.1.nix
|
2011-08-09 18:32:20 +04:00
|
|
|
ghc6101Binary (x : x.ghc6121Prefs) false false lowPrio;
|
2010-04-27 22:21:07 +04:00
|
|
|
|
2010-07-22 22:47:59 +04:00
|
|
|
haskellPackages_ghc6122 =
|
2011-08-05 12:52:35 +04:00
|
|
|
haskellPackagesFun ../development/compilers/ghc/6.12.2.nix
|
2011-08-09 18:32:20 +04:00
|
|
|
ghc6101Binary (x : x.ghc6122Prefs) false false lowPrio;
|
2010-04-25 21:27:21 +04:00
|
|
|
|
2010-07-22 22:47:59 +04:00
|
|
|
haskellPackages_ghc6123 =
|
2011-08-09 15:10:24 +04:00
|
|
|
recurseIntoAttrs
|
|
|
|
(haskellPackagesFun ../development/compilers/ghc/6.12.3.nix
|
2011-08-09 18:32:20 +04:00
|
|
|
ghc6101Binary (x : x.ghc6123Prefs) false false lowPrio);
|
2010-04-25 21:27:21 +04:00
|
|
|
|
2011-03-09 11:29:12 +03:00
|
|
|
# Will never make it into a platform release, severe bugs; leave at lowPrio.
|
2010-09-28 17:48:22 +04:00
|
|
|
haskellPackages_ghc701 =
|
2011-08-05 12:52:35 +04:00
|
|
|
haskellPackagesFun ../development/compilers/ghc/7.0.1.nix
|
2011-08-09 15:18:31 +04:00
|
|
|
ghc6101Binary (x : x.ghc701Prefs) false false lowPrio;
|
2010-09-28 17:48:22 +04:00
|
|
|
|
2011-03-09 11:29:12 +03:00
|
|
|
haskellPackages_ghc702 =
|
2011-08-05 12:52:35 +04:00
|
|
|
haskellPackagesFun ../development/compilers/ghc/7.0.2.nix
|
2011-08-09 18:32:20 +04:00
|
|
|
ghc6101Binary (x : x.ghc702Prefs) false false lowPrio;
|
2011-03-09 11:29:12 +03:00
|
|
|
|
2011-03-29 01:33:21 +04:00
|
|
|
haskellPackages_ghc703 =
|
2011-08-05 12:52:35 +04:00
|
|
|
haskellPackagesFun ../development/compilers/ghc/7.0.3.nix
|
2011-08-09 18:32:20 +04:00
|
|
|
ghc6101Binary (x : x.ghc703Prefs) false false lowPrio;
|
2011-03-29 01:33:21 +04:00
|
|
|
|
2012-01-28 14:20:57 +04:00
|
|
|
# Current default version: 7.0.4.
|
|
|
|
#
|
2011-08-10 11:27:23 +04:00
|
|
|
# The following items are a bit convoluted, but they serve the
|
|
|
|
# following purpose:
|
|
|
|
# - for the default version of GHC, both profiling and
|
|
|
|
# non-profiling versions should be built by Hydra --
|
|
|
|
# therefore, the _no_profiling and _profiling calls;
|
|
|
|
# - however, if a user just upgrades a profile, then the
|
|
|
|
# cabal/libraryProfiling setting should be respected; i.e.,
|
|
|
|
# the versions not matching the profiling config setting
|
|
|
|
# should have low priority -- therefore, the use of
|
|
|
|
# haskellDefaultVersionPrioFun;
|
|
|
|
# - it should be possible to select library versions that
|
|
|
|
# respect the config setting using the standard
|
|
|
|
# haskellPackages_ghc704 path -- therefore, the additional
|
|
|
|
# call in haskellPackages_ghc704, without recurseIntoAttrs,
|
|
|
|
# so that Hydra doesn't build these.
|
|
|
|
haskellDefaultVersionPrioFun =
|
|
|
|
profDefault :
|
|
|
|
if getConfig [ "cabal" "libraryProfiling" ] false == profDefault
|
|
|
|
then (x : x)
|
|
|
|
else lowPrio;
|
|
|
|
|
2011-08-09 15:18:31 +04:00
|
|
|
haskellPackages_ghc704_no_profiling =
|
|
|
|
recurseIntoAttrs
|
|
|
|
(haskellPackagesFun ../development/compilers/ghc/7.0.4.nix
|
2011-08-29 22:57:35 +04:00
|
|
|
(if stdenv.isDarwin then ghc704Binary else ghc6101Binary)
|
|
|
|
(x : x.ghc704Prefs) true false
|
2011-08-10 11:27:23 +04:00
|
|
|
(haskellDefaultVersionPrioFun false));
|
2011-08-09 15:18:31 +04:00
|
|
|
|
|
|
|
haskellPackages_ghc704_profiling =
|
2011-08-09 15:10:24 +04:00
|
|
|
recurseIntoAttrs
|
|
|
|
(haskellPackagesFun ../development/compilers/ghc/7.0.4.nix
|
2011-08-29 22:57:35 +04:00
|
|
|
(if stdenv.isDarwin then ghc704Binary else ghc6101Binary)
|
|
|
|
(x : x.ghc704Prefs) true true
|
2011-08-10 11:27:23 +04:00
|
|
|
(haskellDefaultVersionPrioFun true));
|
2011-08-09 15:18:31 +04:00
|
|
|
|
|
|
|
haskellPackages_ghc704 =
|
|
|
|
haskellPackagesFun ../development/compilers/ghc/7.0.4.nix
|
2011-08-29 11:46:30 +04:00
|
|
|
(if stdenv.isDarwin then ghc704Binary else ghc6101Binary)
|
|
|
|
(x : x.ghc704Prefs) false false (x : x);
|
2011-08-05 12:52:35 +04:00
|
|
|
|
|
|
|
haskellPackages_ghc721 =
|
2012-02-03 01:08:30 +04:00
|
|
|
haskellPackagesFun ../development/compilers/ghc/7.2.1.nix
|
|
|
|
(if stdenv.isDarwin then ghc704Binary else ghc6121Binary)
|
|
|
|
(x : x.ghc721Prefs) false false lowPrio;
|
2011-06-18 16:31:16 +04:00
|
|
|
|
2011-11-13 02:19:03 +04:00
|
|
|
haskellPackages_ghc722 =
|
2012-02-03 01:08:30 +04:00
|
|
|
haskellPackagesFun ../development/compilers/ghc/7.2.2.nix
|
|
|
|
(if stdenv.isDarwin then ghc704Binary else ghc6121Binary)
|
|
|
|
(x : x.ghc722Prefs) false false lowPrio;
|
|
|
|
|
|
|
|
haskellPackages_ghc741 =
|
2011-11-13 02:19:03 +04:00
|
|
|
recurseIntoAttrs
|
2012-02-03 01:08:30 +04:00
|
|
|
(haskellPackagesFun ../development/compilers/ghc/7.4.1.nix
|
2011-11-13 02:19:03 +04:00
|
|
|
(if stdenv.isDarwin then ghc704Binary else ghc6121Binary)
|
2012-02-03 01:08:30 +04:00
|
|
|
(x : x.ghc741Prefs) false false lowPrio);
|
2011-11-13 02:19:03 +04:00
|
|
|
|
2011-09-05 17:29:33 +04:00
|
|
|
# Reasonably current HEAD snapshot. Should *always* be lowPrio.
|
2010-09-28 17:48:22 +04:00
|
|
|
haskellPackages_ghcHEAD =
|
2012-01-16 13:55:03 +04:00
|
|
|
recurseIntoAttrs
|
|
|
|
(haskellPackagesFun ../development/compilers/ghc/head.nix
|
|
|
|
# (haskellPackages_ghc704.ghcWithPackages (self : [ self.alex self.happy ]))
|
|
|
|
(if stdenv.isDarwin then ghc704Binary else ghc6121Binary)
|
|
|
|
(x : x.ghcHEADPrefs) false false lowPrio);
|
2009-09-17 15:45:20 +04:00
|
|
|
|
2010-03-17 02:34:56 +03:00
|
|
|
haxeDist = import ../development/compilers/haxe {
|
|
|
|
inherit fetchurl sourceFromHead stdenv lib ocaml zlib makeWrapper neko;
|
2009-11-30 04:05:04 +03:00
|
|
|
};
|
2010-03-17 02:34:56 +03:00
|
|
|
haxe = haxeDist.haxe;
|
|
|
|
haxelib = haxeDist.haxelib;
|
2009-11-30 04:05:04 +03:00
|
|
|
|
2009-07-10 02:30:19 +04:00
|
|
|
falcon = builderDefsPackage (import ../development/interpreters/falcon) {
|
|
|
|
inherit cmake;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
go = callPackage ../development/compilers/go { };
|
2009-11-14 23:14:28 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gprolog = callPackage ../development/compilers/gprolog { };
|
2009-02-19 16:32:07 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gwt = callPackage ../development/compilers/gwt {
|
2008-02-13 11:43:38 +03:00
|
|
|
inherit (gtkLibs) glib gtk pango atk;
|
|
|
|
libstdcpp5 = gcc33.gcc;
|
|
|
|
};
|
2012-01-19 23:31:25 +04:00
|
|
|
gwt240 = callPackage ../development/compilers/gwt/2.4.0.nix { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ikarus = callPackage ../development/compilers/ikarus { };
|
2008-05-06 11:03:41 +04:00
|
|
|
|
2007-08-20 14:34:49 +04:00
|
|
|
#TODO add packages http://cvs.haskell.org/Hugs/downloads/2006-09/packages/ and test
|
|
|
|
# commented out because it's using the new configuration style proposal which is unstable
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
hugs = callPackage ../development/compilers/hugs { };
|
2007-08-20 14:34:49 +04:00
|
|
|
|
2010-08-03 12:14:13 +04:00
|
|
|
path64 = callPackage ../development/compilers/path64 { };
|
2007-08-20 14:34:49 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
openjdkDarwin = callPackage ../development/compilers/openjdk-darwin { };
|
2009-10-02 16:12:23 +04:00
|
|
|
|
2011-08-01 05:07:47 +04:00
|
|
|
openjdk = callPackage ../development/compilers/openjdk { };
|
|
|
|
|
2011-08-01 22:48:01 +04:00
|
|
|
openjre = callPackage ../development/compilers/openjdk {
|
|
|
|
jreOnly = true;
|
|
|
|
};
|
|
|
|
|
2009-08-28 10:29:21 +04:00
|
|
|
j2sdk14x = (
|
2007-04-16 14:07:06 +04:00
|
|
|
assert system == "i686-linux";
|
|
|
|
import ../development/compilers/jdk/default-1.4.nix {
|
|
|
|
inherit fetchurl stdenv;
|
2009-08-25 10:36:05 +04:00
|
|
|
});
|
2007-03-05 20:13:53 +03:00
|
|
|
|
2009-08-28 10:29:21 +04:00
|
|
|
jdk5 = (
|
2008-01-24 13:14:33 +03:00
|
|
|
assert system == "i686-linux" || system == "x86_64-linux";
|
2010-12-05 14:42:24 +03:00
|
|
|
callPackage ../development/compilers/jdk/default-5.nix { });
|
2008-06-19 02:48:34 +04:00
|
|
|
|
2010-03-26 16:31:11 +03:00
|
|
|
jdk = if stdenv.isDarwin then openjdkDarwin else jdkdistro true false;
|
2007-03-28 22:55:57 +04:00
|
|
|
jre = jdkdistro false false;
|
|
|
|
|
2007-03-28 19:31:00 +04:00
|
|
|
jdkPlugin = jdkdistro true true;
|
2007-03-28 22:55:57 +04:00
|
|
|
jrePlugin = jdkdistro false true;
|
2007-03-28 19:21:43 +04:00
|
|
|
|
2007-04-16 14:22:20 +04:00
|
|
|
supportsJDK =
|
|
|
|
system == "i686-linux" ||
|
|
|
|
system == "x86_64-linux" ||
|
2010-05-27 15:04:45 +04:00
|
|
|
system == "i686-cygwin" ||
|
2007-04-16 14:22:20 +04:00
|
|
|
system == "powerpc-linux";
|
|
|
|
|
2007-04-16 14:07:06 +04:00
|
|
|
jdkdistro = installjdk: pluginSupport:
|
2009-08-28 10:29:21 +04:00
|
|
|
(assert supportsJDK;
|
2007-05-16 18:49:28 +04:00
|
|
|
(if pluginSupport then appendToName "plugin" else x: x) (import ../development/compilers/jdk {
|
2010-05-27 15:04:45 +04:00
|
|
|
inherit fetchurl stdenv unzip installjdk xlibs pluginSupport makeWrapper cabextract;
|
2009-08-25 10:40:26 +04:00
|
|
|
}));
|
2003-12-21 23:52:13 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jikes = callPackage ../development/compilers/jikes { };
|
2004-05-12 19:06:23 +04:00
|
|
|
|
2008-08-15 02:04:30 +04:00
|
|
|
lazarus = builderDefsPackage (import ../development/compilers/fpc/lazarus.nix) {
|
2010-11-16 00:10:18 +03:00
|
|
|
inherit makeWrapper;
|
2011-05-25 13:04:54 +04:00
|
|
|
inherit (gtkLibs) gtk glib pango atk gdk_pixbuf;
|
2008-04-08 19:11:34 +04:00
|
|
|
inherit (xlibs) libXi inputproto libX11 xproto libXext xextproto;
|
2011-05-25 13:04:54 +04:00
|
|
|
fpc = fpc;
|
2008-04-08 19:11:34 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
llvm = callPackage ../development/compilers/llvm { };
|
2008-04-02 23:55:40 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mitscheme = callPackage ../development/compilers/mit-scheme { };
|
2010-03-17 18:32:12 +03:00
|
|
|
|
2010-08-24 12:23:16 +04:00
|
|
|
mlton = callPackage ../development/compilers/mlton { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mono = callPackage ../development/compilers/mono { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
monoDLLFixer = callPackage ../build-support/mono-dll-fixer { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mozart = callPackage ../development/compilers/mozart { };
|
2008-06-12 19:59:59 +04:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
neko = callPackage ../development/compilers/neko { };
|
2009-11-30 04:05:07 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
nasm = callPackage ../development/compilers/nasm { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
2011-11-12 21:19:45 +04:00
|
|
|
nvidia_cg_toolkit = callPackage ../development/compilers/nvidia-cg-toolkit { };
|
|
|
|
|
2012-01-05 21:06:15 +04:00
|
|
|
ocaml = ocaml_3_12_1;
|
2004-07-17 02:58:15 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ocaml_3_08_0 = callPackage ../development/compilers/ocaml/3.08.0.nix { };
|
2009-10-14 19:21:45 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ocaml_3_10_0 = callPackage ../development/compilers/ocaml/3.10.0.nix { };
|
2009-10-14 19:21:45 +04:00
|
|
|
|
2011-12-16 12:11:19 +04:00
|
|
|
ocaml_3_12_1 = lowPrio (callPackage ../development/compilers/ocaml/3.12.1.nix { });
|
2010-12-09 17:03:13 +03:00
|
|
|
|
2011-12-22 01:51:35 +04:00
|
|
|
metaocaml_3_09 = callPackage ../development/compilers/ocaml/metaocaml-3.09.nix { };
|
|
|
|
|
|
|
|
ber_metaocaml_003 = callPackage ../development/compilers/ocaml/ber-metaocaml-003.nix { };
|
|
|
|
|
* Add ocaml packages findlib, camlzip, ocaml-ssl, ocaml-batteries, menhir, camomile, ocaml-lwt, cryptokit, ocaml-cryptgps, ounit, ocaml-react
svn path=/nixpkgs/trunk/; revision=25041
2010-12-09 18:40:04 +03:00
|
|
|
mkOcamlPackages = ocaml: self: let callPackage = newScope self; in rec {
|
|
|
|
inherit ocaml;
|
|
|
|
|
2011-10-04 05:40:45 +04:00
|
|
|
camlidl = callPackage ../development/tools/ocaml/camlidl { };
|
|
|
|
|
2011-11-26 23:39:14 +04:00
|
|
|
camlp5_5_strict = callPackage ../development/tools/ocaml/camlp5/5.15.nix { };
|
2010-12-20 13:32:22 +03:00
|
|
|
|
2011-11-26 23:39:14 +04:00
|
|
|
camlp5_5_transitional = callPackage ../development/tools/ocaml/camlp5/5.15.nix {
|
2010-12-20 13:32:22 +03:00
|
|
|
transitional = true;
|
|
|
|
};
|
|
|
|
|
2011-11-26 23:39:14 +04:00
|
|
|
camlp5_6_strict = callPackage ../development/tools/ocaml/camlp5 { };
|
|
|
|
|
|
|
|
camlp5_6_transitional = callPackage ../development/tools/ocaml/camlp5 {
|
|
|
|
transitional = true;
|
|
|
|
};
|
|
|
|
|
|
|
|
camlp5_strict = camlp5_6_strict;
|
|
|
|
|
|
|
|
camlp5_transitional = camlp5_6_transitional;
|
|
|
|
|
* Add ocaml packages findlib, camlzip, ocaml-ssl, ocaml-batteries, menhir, camomile, ocaml-lwt, cryptokit, ocaml-cryptgps, ounit, ocaml-react
svn path=/nixpkgs/trunk/; revision=25041
2010-12-09 18:40:04 +03:00
|
|
|
camlzip = callPackage ../development/ocaml-modules/camlzip { };
|
|
|
|
|
2011-05-24 22:21:13 +04:00
|
|
|
camomile_0_8_2 = callPackage ../development/ocaml-modules/camomile/0.8.2.nix { };
|
|
|
|
camomile = callPackage ../development/ocaml-modules/camomile { };
|
* Add ocaml packages findlib, camlzip, ocaml-ssl, ocaml-batteries, menhir, camomile, ocaml-lwt, cryptokit, ocaml-cryptgps, ounit, ocaml-react
svn path=/nixpkgs/trunk/; revision=25041
2010-12-09 18:40:04 +03:00
|
|
|
|
|
|
|
cryptokit = callPackage ../development/ocaml-modules/cryptokit { };
|
|
|
|
|
|
|
|
findlib = callPackage ../development/tools/ocaml/findlib { };
|
|
|
|
|
2010-12-31 20:48:55 +03:00
|
|
|
gmetadom = callPackage ../development/ocaml-modules/gmetadom { };
|
2011-02-24 14:25:16 +03:00
|
|
|
|
2010-12-31 20:48:55 +03:00
|
|
|
lablgtk = callPackage ../development/ocaml-modules/lablgtk {
|
|
|
|
inherit (gnome) libgnomecanvas libglade gtksourceview;
|
|
|
|
};
|
|
|
|
|
2011-02-24 14:25:16 +03:00
|
|
|
lablgtkmathview = callPackage ../development/ocaml-modules/lablgtkmathview {
|
2010-12-31 20:48:55 +03:00
|
|
|
gtkmathview = callPackage ../development/libraries/gtkmathview { };
|
2010-12-20 17:58:56 +03:00
|
|
|
};
|
|
|
|
|
* Add ocaml packages findlib, camlzip, ocaml-ssl, ocaml-batteries, menhir, camomile, ocaml-lwt, cryptokit, ocaml-cryptgps, ounit, ocaml-react
svn path=/nixpkgs/trunk/; revision=25041
2010-12-09 18:40:04 +03:00
|
|
|
menhir = callPackage ../development/ocaml-modules/menhir { };
|
|
|
|
|
2011-05-24 22:21:13 +04:00
|
|
|
ocaml_batteries = callPackage ../development/ocaml-modules/batteries {
|
|
|
|
camomile = camomile_0_8_2;
|
|
|
|
};
|
* Add ocaml packages findlib, camlzip, ocaml-ssl, ocaml-batteries, menhir, camomile, ocaml-lwt, cryptokit, ocaml-cryptgps, ounit, ocaml-react
svn path=/nixpkgs/trunk/; revision=25041
2010-12-09 18:40:04 +03:00
|
|
|
|
|
|
|
ocaml_cryptgps = callPackage ../development/ocaml-modules/cryptgps { };
|
|
|
|
|
2010-12-31 20:48:55 +03:00
|
|
|
ocaml_expat = callPackage ../development/ocaml-modules/expat { };
|
|
|
|
|
2011-11-28 03:58:46 +04:00
|
|
|
ocamlgraph = callPackage ../development/ocaml-modules/ocamlgraph { };
|
|
|
|
|
2010-12-31 20:48:55 +03:00
|
|
|
ocaml_http = callPackage ../development/ocaml-modules/http { };
|
|
|
|
|
* Add ocaml packages findlib, camlzip, ocaml-ssl, ocaml-batteries, menhir, camomile, ocaml-lwt, cryptokit, ocaml-cryptgps, ounit, ocaml-react
svn path=/nixpkgs/trunk/; revision=25041
2010-12-09 18:40:04 +03:00
|
|
|
ocaml_lwt = callPackage ../development/ocaml-modules/lwt { };
|
|
|
|
|
2010-12-31 20:48:55 +03:00
|
|
|
ocaml_mysql = callPackage ../development/ocaml-modules/mysql { };
|
|
|
|
|
2010-12-12 20:53:13 +03:00
|
|
|
ocamlnet = callPackage ../development/ocaml-modules/ocamlnet { };
|
|
|
|
|
* Add ocaml packages findlib, camlzip, ocaml-ssl, ocaml-batteries, menhir, camomile, ocaml-lwt, cryptokit, ocaml-cryptgps, ounit, ocaml-react
svn path=/nixpkgs/trunk/; revision=25041
2010-12-09 18:40:04 +03:00
|
|
|
ocaml_pcre = callPackage ../development/ocaml-modules/pcre {
|
|
|
|
inherit pcre;
|
|
|
|
};
|
|
|
|
|
|
|
|
ocaml_react = callPackage ../development/ocaml-modules/react { };
|
|
|
|
|
2010-12-11 18:05:26 +03:00
|
|
|
ocaml_sqlite3 = callPackage ../development/ocaml-modules/sqlite3 { };
|
|
|
|
|
* Add ocaml packages findlib, camlzip, ocaml-ssl, ocaml-batteries, menhir, camomile, ocaml-lwt, cryptokit, ocaml-cryptgps, ounit, ocaml-react
svn path=/nixpkgs/trunk/; revision=25041
2010-12-09 18:40:04 +03:00
|
|
|
ocaml_ssl = callPackage ../development/ocaml-modules/ssl { };
|
|
|
|
|
|
|
|
ounit = callPackage ../development/ocaml-modules/ounit { };
|
2010-12-31 20:48:55 +03:00
|
|
|
|
2011-11-28 03:58:46 +04:00
|
|
|
ulex = callPackage ../development/ocaml-modules/ulex { };
|
|
|
|
|
2010-12-31 20:48:55 +03:00
|
|
|
ulex08 = callPackage ../development/ocaml-modules/ulex/0.8 {
|
2011-11-26 23:39:14 +04:00
|
|
|
camlp5 = camlp5_5_transitional;
|
2010-12-31 20:48:55 +03:00
|
|
|
};
|
2012-01-16 14:20:13 +04:00
|
|
|
|
|
|
|
ocaml_typeconv = callPackage ../development/ocaml-modules/typeconv { };
|
|
|
|
|
|
|
|
ocaml_sexplib = callPackage ../development/ocaml-modules/sexplib { };
|
|
|
|
|
|
|
|
ocaml_extlib = callPackage ../development/ocaml-modules/extlib { };
|
|
|
|
|
|
|
|
pycaml = callPackage ../development/ocaml-modules/pycaml { };
|
* Add ocaml packages findlib, camlzip, ocaml-ssl, ocaml-batteries, menhir, camomile, ocaml-lwt, cryptokit, ocaml-cryptgps, ounit, ocaml-react
svn path=/nixpkgs/trunk/; revision=25041
2010-12-09 18:40:04 +03:00
|
|
|
};
|
|
|
|
|
2012-01-05 21:06:15 +04:00
|
|
|
ocamlPackages = recurseIntoAttrs ocamlPackages_3_12_1;
|
* Add ocaml packages findlib, camlzip, ocaml-ssl, ocaml-batteries, menhir, camomile, ocaml-lwt, cryptokit, ocaml-cryptgps, ounit, ocaml-react
svn path=/nixpkgs/trunk/; revision=25041
2010-12-09 18:40:04 +03:00
|
|
|
ocamlPackages_3_10_0 = mkOcamlPackages ocaml_3_10_0 pkgs.ocamlPackages_3_10_0;
|
2011-12-16 13:35:13 +04:00
|
|
|
ocamlPackages_3_12_1 = mkOcamlPackages ocaml_3_12_1 pkgs.ocamlPackages_3_12_1;
|
* Add ocaml packages findlib, camlzip, ocaml-ssl, ocaml-batteries, menhir, camomile, ocaml-lwt, cryptokit, ocaml-cryptgps, ounit, ocaml-react
svn path=/nixpkgs/trunk/; revision=25041
2010-12-09 18:40:04 +03:00
|
|
|
|
2012-01-16 14:20:13 +04:00
|
|
|
ocaml_make = callPackage ../development/ocaml-modules/ocamlmake { };
|
|
|
|
|
2011-12-16 13:35:13 +04:00
|
|
|
opa = let callPackage = newScope pkgs.ocamlPackages_3_12_1; in callPackage ../development/compilers/opa { };
|
|
|
|
|
|
|
|
ocamlnat = let callPackage = newScope pkgs.ocamlPackages_3_12_1; in callPackage ../development/ocaml-modules/ocamlnat { };
|
2011-11-28 19:52:46 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
opencxx = callPackage ../development/compilers/opencxx {
|
2006-09-15 19:28:53 +04:00
|
|
|
gcc = gcc33;
|
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
qcmm = callPackage ../development/compilers/qcmm {
|
2006-03-01 12:18:22 +03:00
|
|
|
lua = lua4;
|
2009-10-14 19:21:45 +04:00
|
|
|
ocaml = ocaml_3_08_0;
|
2006-02-02 20:07:07 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
roadsend = callPackage ../development/compilers/roadsend { };
|
2008-02-08 04:57:31 +03:00
|
|
|
|
2011-08-03 12:43:47 +04:00
|
|
|
# TODO: the corresponding nix file is missing
|
|
|
|
# rust = pkgsi686Linux.callPackage ../development/compilers/rust {};
|
2011-08-02 23:46:28 +04:00
|
|
|
|
2009-05-31 10:07:25 +04:00
|
|
|
sbcl = builderDefsPackage (import ../development/compilers/sbcl) {
|
2010-02-17 09:50:45 +03:00
|
|
|
inherit makeWrapper clisp;
|
2009-05-31 10:07:25 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
scala = callPackage ../development/compilers/scala { };
|
2008-04-12 02:06:32 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
stalin = callPackage ../development/compilers/stalin { };
|
2008-05-29 16:10:10 +04:00
|
|
|
|
2010-09-30 14:49:02 +04:00
|
|
|
strategoPackages = strategoPackages018;
|
2005-03-03 20:19:58 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
strategoPackages016 = callPackage ../development/compilers/strategoxt/0.16.nix {
|
2006-06-24 00:11:36 +04:00
|
|
|
stdenv = overrideInStdenv stdenv [gnumake380];
|
2005-10-31 17:28:11 +03:00
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
strategoPackages017 = callPackage ../development/compilers/strategoxt/0.17.nix {
|
2009-11-27 23:22:43 +03:00
|
|
|
readline = readline5;
|
2005-06-30 20:54:25 +04:00
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
strategoPackages018 = callPackage ../development/compilers/strategoxt/0.18.nix {
|
2009-12-09 17:07:09 +03:00
|
|
|
readline = readline5;
|
2009-09-15 15:36:41 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
metaBuildEnv = callPackage ../development/compilers/meta-environment/meta-build-env { };
|
2009-04-03 13:22:20 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
swiProlog = callPackage ../development/compilers/swi-prolog { };
|
2008-03-07 00:53:54 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
tinycc = callPackage ../development/compilers/tinycc { };
|
2008-10-31 19:52:44 +03:00
|
|
|
|
2010-08-24 12:25:07 +04:00
|
|
|
urweb = callPackage ../development/compilers/urweb { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
vala = callPackage ../development/compilers/vala { };
|
2010-07-09 17:15:40 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
visualcpp = callPackage ../development/compilers/visual-c++ { };
|
2006-06-02 13:56:10 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
vs90wrapper = callPackage ../development/compilers/vs90wrapper { };
|
2006-06-02 13:56:10 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
webdsl = callPackage ../development/compilers/webdsl { };
|
2008-01-29 14:46:34 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
win32hello = callPackage ../development/compilers/visual-c++/test { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
2008-06-27 22:26:19 +04:00
|
|
|
wrapGCCWith = gccWrapper: glibc: baseGCC: gccWrapper {
|
2009-12-22 02:02:06 +03:00
|
|
|
nativeTools = stdenv ? gcc && stdenv.gcc.nativeTools;
|
|
|
|
nativeLibc = stdenv ? gcc && stdenv.gcc.nativeLibc;
|
|
|
|
nativePrefix = if stdenv ? gcc then stdenv.gcc.nativePrefix else "";
|
|
|
|
gcc = baseGCC;
|
|
|
|
libc = glibc;
|
2010-12-05 00:45:37 +03:00
|
|
|
shell = bash;
|
2009-12-22 02:02:06 +03:00
|
|
|
inherit stdenv binutils coreutils zlib;
|
|
|
|
};
|
|
|
|
|
2011-10-19 00:03:09 +04:00
|
|
|
wrapClangWith = clangWrapper: glibc: baseClang: clangWrapper {
|
|
|
|
nativeTools = stdenv ? gcc && stdenv.gcc.nativeTools;
|
|
|
|
nativeLibc = stdenv ? gcc && stdenv.gcc.nativeLibc;
|
|
|
|
nativePrefix = if stdenv ? gcc then stdenv.gcc.nativePrefix else "";
|
|
|
|
clang = baseClang;
|
|
|
|
libc = glibc;
|
|
|
|
shell = bash;
|
2011-12-20 03:58:57 +04:00
|
|
|
binutils = stdenv.gcc.binutils;
|
|
|
|
inherit stdenv coreutils zlib;
|
2011-10-19 00:03:09 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
wrapClang = wrapClangWith (import ../build-support/clang-wrapper) glibc;
|
|
|
|
|
2010-01-17 00:41:27 +03:00
|
|
|
wrapGCC = wrapGCCWith (import ../build-support/gcc-wrapper) glibc;
|
2009-12-22 02:02:06 +03:00
|
|
|
|
2009-11-15 08:28:35 +03:00
|
|
|
wrapGCCCross =
|
|
|
|
{gcc, libc, binutils, cross, shell ? "", name ? "gcc-cross-wrapper"}:
|
2010-01-21 18:39:11 +03:00
|
|
|
|
Big fixes in the cross build:
- Before this changes, cflags and ldflags for the native and the cross compiler
got mixed. Not all the gcc-wrapper/gcc-cross-wrapper variables are
independant now, but enough, I think.
- Fixed the generic stdenv expression, which did a big mess on buildInputs and
buildNativeInputs. Now it distinguishes when there is a stdenvCross or not.
Maybe we should have a single stdenv and forget about the stdenvCross
adapter - this could end in a stdenv a bit complex, but simpler than the
generic stdenv + adapter.
- Added basic support in pkgconfig for cross-builds: a single PKG_CONFIG_PATH
now works for both the cross and the native compilers, but I think this
should work well for most cases I can think of.
- I tried to fix the guile expression to cross-biuld; guile is built, but not
its manual, so the derivation still fails. Guile requires patching to
cross-build, as far as I understnad.
- Made the glibcCross build to be done through the usage of a
gcc-cross-wrapper over the gcc-cross-stage-static, instead of using it
directly.
- Trying to make physfs (a neverball dependency) cross build.
- Updated the gcc expression to support building a cross compiler without getting
derivation variables mixed with those of the stdenvCross.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18534
2009-11-22 22:51:45 +03:00
|
|
|
forceBuildDrv (import ../build-support/gcc-cross-wrapper {
|
2009-11-15 08:28:35 +03:00
|
|
|
nativeTools = false;
|
|
|
|
nativeLibc = false;
|
2009-11-21 05:42:52 +03:00
|
|
|
noLibc = (libc == null);
|
- Removed all *NoCross expressions I dupilcated in nixpkgs, while maintaining
the cross compilation functionality.
- I renamed some expected stdenv.mkDerivation parameter attributes so we can
keep this branch properly updated from trunk. We agreed with Nicolas Pierron
doing a massive renaming, so all current buildInputs become hostInputs (input
as build for the host machine, in autotools terminology) , and
then buildInputs would mean "input as for the build machine".
By now, the specific "input as for the build machine" is specified through
buildNativeInputs. We should fix this in the merge to trunk.
- I made the generic stdenv understand the buildNativeInputs, otherwise if
we start changing nixpkgs expressions so they distinguish the current
buildInputs into buildInputs and buildNativeInputs, we could break even more
nixpkgs for other platforms.
- I changed the default result of mkDerivation so it becomes the derivation for
to be run in the build machine. This allows, without any special rewriting,
"fetchurl" derivations to be always results for the build machine to use
them.
- The change above implies that, for anyone wanting to cross-compile, has to
build the hostDrv of the wanted derivation. For example, after this commit,
the usual test of "nix-build -A bison.hostDrv arm.nix" works. I described
the contents of this arm.nix in r18398.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18471
2009-11-19 22:03:34 +03:00
|
|
|
inherit stdenv gcc binutils libc shell name cross;
|
Big fixes in the cross build:
- Before this changes, cflags and ldflags for the native and the cross compiler
got mixed. Not all the gcc-wrapper/gcc-cross-wrapper variables are
independant now, but enough, I think.
- Fixed the generic stdenv expression, which did a big mess on buildInputs and
buildNativeInputs. Now it distinguishes when there is a stdenvCross or not.
Maybe we should have a single stdenv and forget about the stdenvCross
adapter - this could end in a stdenv a bit complex, but simpler than the
generic stdenv + adapter.
- Added basic support in pkgconfig for cross-builds: a single PKG_CONFIG_PATH
now works for both the cross and the native compilers, but I think this
should work well for most cases I can think of.
- I tried to fix the guile expression to cross-biuld; guile is built, but not
its manual, so the derivation still fails. Guile requires patching to
cross-build, as far as I understnad.
- Made the glibcCross build to be done through the usage of a
gcc-cross-wrapper over the gcc-cross-stage-static, instead of using it
directly.
- Trying to make physfs (a neverball dependency) cross build.
- Updated the gcc expression to support building a cross compiler without getting
derivation variables mixed with those of the stdenvCross.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18534
2009-11-22 22:51:45 +03:00
|
|
|
});
|
2009-11-15 08:28:35 +03:00
|
|
|
|
2008-03-04 19:20:11 +03:00
|
|
|
# FIXME: This is a specific hack for GCC-UPC. Eventually, we may
|
|
|
|
# want to merge `gcc-upc-wrapper' and `gcc-wrapper'.
|
|
|
|
wrapGCCUPC = baseGCC: import ../build-support/gcc-upc-wrapper {
|
|
|
|
nativeTools = stdenv ? gcc && stdenv.gcc.nativeTools;
|
2007-05-16 19:15:46 +04:00
|
|
|
nativeLibc = stdenv ? gcc && stdenv.gcc.nativeLibc;
|
2006-09-15 19:28:53 +04:00
|
|
|
gcc = baseGCC;
|
2006-10-25 00:53:54 +04:00
|
|
|
libc = glibc;
|
|
|
|
inherit stdenv binutils;
|
2006-06-02 14:09:19 +04:00
|
|
|
};
|
|
|
|
|
2008-03-13 04:13:53 +03:00
|
|
|
# prolog
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
yap = callPackage ../development/compilers/yap { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
yasm = callPackage ../development/compilers/yasm { };
|
2008-06-19 02:48:34 +04:00
|
|
|
|
2006-10-18 18:04:55 +04:00
|
|
|
### DEVELOPMENT / INTERPRETERS
|
|
|
|
|
2009-08-13 18:32:52 +04:00
|
|
|
acl2 = builderDefsPackage ../development/interpreters/acl2 {
|
|
|
|
inherit sbcl;
|
|
|
|
};
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2011-04-08 10:52:31 +04:00
|
|
|
angelscript = callPackage ../development/interpreters/angelscript {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
clisp = callPackage ../development/interpreters/clisp { };
|
2009-05-31 10:07:25 +04:00
|
|
|
|
|
|
|
# compatibility issues in 2.47 - at list 2.44.1 is known good
|
|
|
|
# for sbcl bootstrap
|
2010-08-03 01:40:34 +04:00
|
|
|
clisp_2_44_1 = callPackage ../development/interpreters/clisp/2.44.1.nix {
|
2011-12-14 18:31:56 +04:00
|
|
|
libsigsegv = libsigsegv_25;
|
|
|
|
};
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2011-09-01 17:38:59 +04:00
|
|
|
clojure = callPackage ../development/interpreters/clojure { };
|
|
|
|
|
|
|
|
clojure_binary = callPackage ../development/interpreters/clojure/binary.nix { };
|
|
|
|
|
|
|
|
clojure_wrapper = callPackage ../development/interpreters/clojure/wrapper.nix {
|
|
|
|
#clojure = clojure_binary;
|
|
|
|
};
|
|
|
|
|
2011-09-10 01:15:20 +04:00
|
|
|
clooj_standalone_binary = callPackage ../development/interpreters/clojure/clooj.nix { };
|
|
|
|
|
|
|
|
clooj_wrapper = callPackage ../development/interpreters/clojure/clooj-wrapper.nix {
|
|
|
|
clooj = clooj_standalone_binary;
|
|
|
|
};
|
2011-09-01 17:38:59 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
erlang = callPackage ../development/interpreters/erlang { };
|
2008-01-23 13:06:07 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
erlangR13B = callPackage ../development/interpreters/erlang/R13B.nix { };
|
2010-07-05 16:47:35 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
groovy = callPackage ../development/interpreters/groovy { };
|
2010-03-30 03:36:32 +04:00
|
|
|
|
2011-02-16 16:18:08 +03:00
|
|
|
guile_1_8 = callPackage ../development/interpreters/guile/1.8.nix { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2011-02-16 16:18:08 +03:00
|
|
|
guile_2_0 = callPackage ../development/interpreters/guile { };
|
2009-09-16 16:46:17 +04:00
|
|
|
|
2011-02-16 16:18:08 +03:00
|
|
|
guile = guile_2_0;
|
2009-09-16 16:46:17 +04:00
|
|
|
|
2011-10-17 12:36:07 +04:00
|
|
|
io = callPackage ../development/interpreters/io { };
|
2008-11-11 11:53:47 +03:00
|
|
|
|
2011-03-17 18:36:38 +03:00
|
|
|
j = callPackage ../development/interpreters/j {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
kaffe = callPackage ../development/interpreters/kaffe { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2011-05-03 10:58:01 +04:00
|
|
|
kona = callPackage ../development/interpreters/kona {};
|
|
|
|
|
2011-09-11 21:05:48 +04:00
|
|
|
love = callPackage ../development/interpreters/love {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
lua4 = callPackage ../development/interpreters/lua-4 { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
lua5 = callPackage ../development/interpreters/lua-5 { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2011-07-10 18:04:19 +04:00
|
|
|
lua5_0 = callPackage ../development/interpreters/lua-5/5.0.3.nix { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
maude = callPackage ../development/interpreters/maude { };
|
2008-07-15 13:58:30 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
octave = callPackage ../development/interpreters/octave {
|
2012-02-22 02:09:48 +04:00
|
|
|
fltk = fltk13;
|
2006-10-18 18:04:55 +04:00
|
|
|
};
|
|
|
|
|
2008-12-03 01:55:45 +03:00
|
|
|
# mercurial (hg) bleeding edge version
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
octaveHG = callPackage ../development/interpreters/octave/hg.nix { };
|
2008-12-03 01:55:45 +03:00
|
|
|
|
2011-10-27 19:35:43 +04:00
|
|
|
perl58 = callPackage ../development/interpreters/perl/5.8 {
|
2010-01-26 21:10:59 +03:00
|
|
|
impureLibcPath = if stdenv.isLinux then null else "/usr";
|
|
|
|
};
|
2008-02-22 17:43:00 +03:00
|
|
|
|
2011-10-27 20:09:22 +04:00
|
|
|
perl510 = callPackage ../development/interpreters/perl/5.10 { };
|
2009-10-02 23:05:39 +04:00
|
|
|
|
2011-10-27 19:58:25 +04:00
|
|
|
perl514 = callPackage ../development/interpreters/perl/5.14 {
|
|
|
|
fetchurl = fetchurlBoot;
|
|
|
|
};
|
|
|
|
|
2011-10-27 20:09:22 +04:00
|
|
|
perl = if system != "i686-cygwin" then perl514 else sysPerl;
|
2009-11-05 12:11:25 +03:00
|
|
|
|
2010-11-26 17:26:15 +03:00
|
|
|
php = php5_3;
|
|
|
|
|
|
|
|
php5_2 = makeOverridable (import ../development/interpreters/php/5.2.nix) {
|
|
|
|
inherit
|
|
|
|
stdenv fetchurl lib composableDerivation autoconf automake
|
2011-05-03 12:25:45 +04:00
|
|
|
flex bison apacheHttpd mysql libxml2 readline
|
2010-11-26 17:26:15 +03:00
|
|
|
zlib curl gd postgresql openssl pkgconfig sqlite getConfig libiconv libjpeg libpng;
|
|
|
|
};
|
|
|
|
|
|
|
|
php5_3 = makeOverridable (import ../development/interpreters/php/5.3.nix) {
|
2008-06-06 17:03:55 +04:00
|
|
|
inherit
|
2008-12-20 04:20:35 +03:00
|
|
|
stdenv fetchurl lib composableDerivation autoconf automake
|
2011-05-03 12:25:45 +04:00
|
|
|
flex bison apacheHttpd mysql libxml2 readline
|
2010-05-29 22:26:54 +04:00
|
|
|
zlib curl gd postgresql openssl pkgconfig sqlite getConfig libiconv libjpeg libpng;
|
2008-01-03 13:46:18 +03:00
|
|
|
};
|
2007-11-06 00:13:16 +03:00
|
|
|
|
2011-04-14 15:12:04 +04:00
|
|
|
php_apc = callPackage ../development/libraries/php-apc { };
|
|
|
|
|
2011-04-30 01:01:09 +04:00
|
|
|
php_xcache = callPackage ../development/libraries/php-xcache { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
phpXdebug = callPackage ../development/interpreters/php-xdebug { };
|
2010-01-06 20:04:38 +03:00
|
|
|
|
2011-03-28 12:16:15 +04:00
|
|
|
picolisp = callPackage ../development/interpreters/picolisp {};
|
|
|
|
|
2008-07-17 13:57:47 +04:00
|
|
|
pltScheme = builderDefsPackage (import ../development/interpreters/plt-scheme) {
|
2008-07-19 00:11:02 +04:00
|
|
|
inherit cairo fontconfig freetype libjpeg libpng openssl
|
2008-07-17 13:57:47 +04:00
|
|
|
perl mesa zlib which;
|
2008-07-19 00:11:02 +04:00
|
|
|
inherit (xorg) libX11 libXaw libXft libXrender libICE xproto
|
|
|
|
renderproto pixman libSM libxcb libXext xextproto libXmu
|
2008-07-17 13:57:47 +04:00
|
|
|
libXt;
|
2008-08-15 02:04:30 +04:00
|
|
|
};
|
2008-07-17 13:57:47 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
polyml = callPackage ../development/compilers/polyml { };
|
2009-12-10 16:16:06 +03:00
|
|
|
|
2011-04-08 12:00:55 +04:00
|
|
|
pure = callPackage ../development/interpreters/pure {};
|
2007-11-05 11:32:20 +03:00
|
|
|
|
2011-01-04 19:30:54 +03:00
|
|
|
python = python27;
|
2012-01-08 18:43:21 +04:00
|
|
|
python3 = python32;
|
2010-04-21 14:51:15 +04:00
|
|
|
|
2011-04-07 01:57:30 +04:00
|
|
|
python26 = callPackage ../development/interpreters/python/2.6 { };
|
2009-10-20 03:10:09 +04:00
|
|
|
|
2011-01-04 17:47:36 +03:00
|
|
|
python27 = callPackage ../development/interpreters/python/2.7 { };
|
2008-12-02 15:27:05 +03:00
|
|
|
|
2012-01-08 18:43:21 +04:00
|
|
|
python31 = callPackage ../development/interpreters/python/3.1 {
|
2011-02-02 14:16:31 +03:00
|
|
|
arch = if stdenv.isDarwin then pkgs.darwinArchUtility else null;
|
|
|
|
sw_vers = if stdenv.isDarwin then pkgs.darwinSwVersUtility else null;
|
2011-02-02 14:16:36 +03:00
|
|
|
};
|
2010-08-11 19:49:03 +04:00
|
|
|
|
2011-04-20 00:17:17 +04:00
|
|
|
python32 = callPackage ../development/interpreters/python/3.2 {
|
|
|
|
arch = if stdenv.isDarwin then pkgs.darwinArchUtility else null;
|
|
|
|
sw_vers = if stdenv.isDarwin then pkgs.darwinSwVersUtility else null;
|
|
|
|
};
|
2010-08-11 19:49:03 +04:00
|
|
|
|
2011-10-14 13:47:30 +04:00
|
|
|
pythonFull = python27Full;
|
|
|
|
|
|
|
|
python26Full = callPackage ../development/interpreters/python/wrapper.nix {
|
|
|
|
extraLibs = lib.attrValues python26.modules;
|
|
|
|
python = python26;
|
|
|
|
};
|
|
|
|
|
|
|
|
python27Full = callPackage ../development/interpreters/python/wrapper.nix {
|
|
|
|
extraLibs = lib.attrValues python27.modules;
|
|
|
|
python = python27;
|
2011-03-28 16:31:56 +04:00
|
|
|
};
|
2010-04-29 12:54:02 +04:00
|
|
|
|
2011-09-23 21:00:13 +04:00
|
|
|
pythonhomeWrapper = callPackage ../development/interpreters/python/pythonhome-wrapper.nix { };
|
|
|
|
|
2008-03-17 16:45:50 +03:00
|
|
|
pyrex = pyrex095;
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pyrex095 = callPackage ../development/interpreters/pyrex/0.9.5.nix { };
|
2007-11-05 11:32:20 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pyrex096 = callPackage ../development/interpreters/pyrex/0.9.6.nix { };
|
2007-11-08 17:34:54 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
qi = callPackage ../development/compilers/qi { };
|
2007-11-08 17:34:54 +03:00
|
|
|
|
2011-02-16 03:48:58 +03:00
|
|
|
racket = callPackage ../development/interpreters/racket {
|
|
|
|
inherit (gtkLibs) pango glib gtk;
|
|
|
|
};
|
2010-09-21 16:31:11 +04:00
|
|
|
|
2011-09-02 12:05:51 +04:00
|
|
|
regina = callPackage ../development/interpreters/regina {};
|
|
|
|
|
2011-09-30 01:55:12 +04:00
|
|
|
ruby18 = callPackage ../development/interpreters/ruby/ruby-18.nix { };
|
2011-10-03 19:35:50 +04:00
|
|
|
ruby19 = callPackage ../development/interpreters/ruby/ruby-19.nix { };
|
2012-02-27 14:12:06 +04:00
|
|
|
|
2012-02-26 15:07:56 +04:00
|
|
|
ruby = ruby19;
|
2008-04-11 13:32:27 +04:00
|
|
|
|
2011-01-21 11:24:52 +03:00
|
|
|
rubyLibs = recurseIntoAttrs (callPackage ../development/interpreters/ruby/libs.nix { });
|
2008-04-11 13:32:27 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rake = callPackage ../development/ruby-modules/rake { };
|
2008-10-05 13:04:30 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rubySqlite3 = callPackage ../development/ruby-modules/sqlite3 { };
|
2008-10-05 13:04:30 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
rLang = callPackage ../development/interpreters/r-lang {
|
2008-08-29 17:53:28 +04:00
|
|
|
withBioconductor = getConfig ["rLang" "withBioconductor"] false;
|
2008-05-07 15:24:28 +04:00
|
|
|
};
|
|
|
|
|
2011-01-21 11:24:52 +03:00
|
|
|
rubygemsFun = ruby: builderDefsPackage (import ../development/interpreters/ruby/rubygems.nix) {
|
2008-04-11 13:32:27 +04:00
|
|
|
inherit ruby makeWrapper;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2012-02-18 01:51:06 +04:00
|
|
|
rubygems = hiPrio (rubygemsFun ruby);
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rq = callPackage ../applications/networking/cluster/rq { };
|
2008-08-29 17:53:28 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
scsh = callPackage ../development/interpreters/scsh { };
|
2009-11-07 14:17:53 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
spidermonkey = callPackage ../development/interpreters/spidermonkey { };
|
2010-08-08 01:44:13 +04:00
|
|
|
spidermonkey_1_8_0rc1 = callPackage ../development/interpreters/spidermonkey/1.8.0-rc1.nix { };
|
2011-12-15 16:13:36 +04:00
|
|
|
spidermonkey_185 = callPackage ../development/interpreters/spidermonkey/185-1.0.0.nix { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
sysPerl = callPackage ../development/interpreters/sys-perl { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
tcl = callPackage ../development/interpreters/tcl { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
xulrunnerWrapper = {application, launcher}:
|
|
|
|
import ../development/interpreters/xulrunner/wrapper {
|
2011-07-27 20:40:12 +04:00
|
|
|
inherit stdenv application launcher xulrunner;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2011-08-19 16:13:48 +04:00
|
|
|
xulrunner = pkgs.firefoxPkgs.xulrunner;
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
### DEVELOPMENT / MISC
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2011-08-23 11:56:34 +04:00
|
|
|
avrgcclibc = callPackage ../development/misc/avr-gcc-with-avr-libc {};
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
avr8burnomat = callPackage ../development/misc/avr8-burn-omat { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
/*
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
toolbus = callPackage ../development/interpreters/toolbus { };
|
2007-12-31 01:02:04 +03:00
|
|
|
*/
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2009-12-11 16:58:23 +03:00
|
|
|
sourceFromHead = import ../build-support/source-from-head-fun.nix {
|
|
|
|
inherit getConfig;
|
2008-03-09 03:08:45 +03:00
|
|
|
};
|
2008-03-06 05:46:29 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ecj = callPackage ../development/eclipse/ecj { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2010-03-01 19:20:47 +03:00
|
|
|
ecjDarwin = ecj.override { gcj = openjdkDarwin; ant = antDarwin; };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jdtsdk = callPackage ../development/eclipse/jdt-sdk { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2012-01-19 00:32:20 +04:00
|
|
|
jruby165 = callPackage ../development/interpreters/jruby { };
|
2009-06-26 20:52:58 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
guileCairo = callPackage ../development/guile-modules/guile-cairo { };
|
2009-10-06 02:21:24 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
guileGnome = callPackage ../development/guile-modules/guile-gnome {
|
2009-10-06 02:21:50 +04:00
|
|
|
gconf = gnome.GConf;
|
2011-10-08 16:06:03 +04:00
|
|
|
inherit (gnome) glib gnome_vfs gtk libglade libgnome libgnomecanvas
|
2009-10-06 02:21:50 +04:00
|
|
|
libgnomeui pango;
|
|
|
|
};
|
|
|
|
|
2010-09-05 19:19:23 +04:00
|
|
|
guile_lib = callPackage ../development/guile-modules/guile-lib { };
|
2008-02-12 14:16:53 +03:00
|
|
|
|
2011-01-21 01:06:35 +03:00
|
|
|
guile_ncurses = callPackage ../development/guile-modules/guile-ncurses { };
|
|
|
|
|
2009-08-28 10:29:21 +04:00
|
|
|
windowssdk = (
|
2009-08-25 10:36:05 +04:00
|
|
|
import ../development/misc/windows-sdk {
|
|
|
|
inherit fetchurl stdenv cabextract;
|
|
|
|
});
|
2006-10-18 18:04:55 +04:00
|
|
|
|
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
### DEVELOPMENT / TOOLS
|
2006-10-18 18:04:55 +04:00
|
|
|
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
antlr = callPackage ../development/tools/parsing/antlr/2.7.7.nix { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
antlr3 = callPackage ../development/tools/parsing/antlr { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2010-09-30 14:49:02 +04:00
|
|
|
antDarwin = apacheAnt.override rec { jdk = openjdkDarwin; name = "ant-" + jdk.name; } ;
|
2009-10-02 16:27:24 +04:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
ant = apacheAnt;
|
2010-10-04 13:49:25 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
apacheAnt = callPackage ../development/tools/build-managers/apache-ant {
|
2010-09-30 14:49:02 +04:00
|
|
|
name = "ant-" + jdk.name;
|
|
|
|
};
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
apacheAnt14 = callPackage ../development/tools/build-managers/apache-ant {
|
2007-12-31 01:02:04 +03:00
|
|
|
jdk = j2sdk14x;
|
|
|
|
name = "ant-" + j2sdk14x.name;
|
|
|
|
};
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
apacheAntGcj = callPackage ../development/tools/build-managers/apache-ant/from-source.nix { # must be either pre-built or built with GCJ *alone*
|
2010-05-26 18:53:13 +04:00
|
|
|
gcj = gcj.gcc; # use the raw GCJ, which has ${gcj}/lib/jvm
|
2009-09-24 18:49:15 +04:00
|
|
|
};
|
|
|
|
|
2012-01-25 17:52:18 +04:00
|
|
|
astyle = callPackage ../development/tools/misc/astyle { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
autobuild = callPackage ../development/tools/misc/autobuild { };
|
2008-07-29 01:29:17 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
autoconf = callPackage ../development/tools/misc/autoconf { };
|
2008-06-16 17:15:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
autoconf213 = callPackage ../development/tools/misc/autoconf/2.13.nix { };
|
2009-01-03 16:44:04 +03:00
|
|
|
|
2010-10-15 16:09:10 +04:00
|
|
|
automake = automake111x;
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
automake17x = callPackage ../development/tools/misc/automake/automake-1.7.x.nix { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
automake19x = callPackage ../development/tools/misc/automake/automake-1.9.x.nix { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
automake110x = callPackage ../development/tools/misc/automake/automake-1.10.x.nix { };
|
2008-02-12 17:00:26 +03:00
|
|
|
|
2010-09-09 21:07:57 +04:00
|
|
|
automake111x = callPackage ../development/tools/misc/automake/automake-1.11.x.nix {
|
2011-01-24 01:53:54 +03:00
|
|
|
doCheck = !stdenv.isArm && !stdenv.isCygwin
|
2011-01-24 01:48:08 +03:00
|
|
|
# Some of the parallel tests seem to hang on `i386-pc-solaris2.11'.
|
2012-01-08 19:41:17 +04:00
|
|
|
&& stdenv.system != "i686-solaris"
|
|
|
|
|
|
|
|
# One test fails to terminate on FreeBSD: <http://bugs.gnu.org/8788>.
|
|
|
|
&& !stdenv.isFreeBSD;
|
2010-09-09 21:07:57 +04:00
|
|
|
};
|
2009-05-20 16:20:51 +04:00
|
|
|
|
2011-02-22 09:19:05 +03:00
|
|
|
automoc4 = callPackage ../development/tools/misc/automoc4 { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
avrdude = callPackage ../development/tools/misc/avrdude { };
|
2007-09-03 16:10:57 +04:00
|
|
|
|
2011-04-13 09:47:51 +04:00
|
|
|
bam = callPackage ../development/tools/build-managers/bam {};
|
|
|
|
|
2010-12-13 02:35:16 +03:00
|
|
|
binutils = callPackage ../development/tools/misc/binutils {
|
2010-08-06 14:34:34 +04:00
|
|
|
inherit noSysDirs;
|
|
|
|
};
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2011-05-04 14:03:46 +04:00
|
|
|
binutils_gold = callPackage ../development/tools/misc/binutils {
|
|
|
|
inherit noSysDirs;
|
|
|
|
gold = true;
|
|
|
|
};
|
|
|
|
|
2010-03-07 02:36:55 +03:00
|
|
|
binutilsCross = forceBuildDrv (import ../development/tools/misc/binutils {
|
2010-12-13 11:04:14 +03:00
|
|
|
inherit stdenv fetchurl zlib;
|
|
|
|
noSysDirs = true;
|
|
|
|
cross = assert crossSystem != null; crossSystem;
|
Big fixes in the cross build:
- Before this changes, cflags and ldflags for the native and the cross compiler
got mixed. Not all the gcc-wrapper/gcc-cross-wrapper variables are
independant now, but enough, I think.
- Fixed the generic stdenv expression, which did a big mess on buildInputs and
buildNativeInputs. Now it distinguishes when there is a stdenvCross or not.
Maybe we should have a single stdenv and forget about the stdenvCross
adapter - this could end in a stdenv a bit complex, but simpler than the
generic stdenv + adapter.
- Added basic support in pkgconfig for cross-builds: a single PKG_CONFIG_PATH
now works for both the cross and the native compilers, but I think this
should work well for most cases I can think of.
- I tried to fix the guile expression to cross-biuld; guile is built, but not
its manual, so the derivation still fails. Guile requires patching to
cross-build, as far as I understnad.
- Made the glibcCross build to be done through the usage of a
gcc-cross-wrapper over the gcc-cross-stage-static, instead of using it
directly.
- Trying to make physfs (a neverball dependency) cross build.
- Updated the gcc expression to support building a cross compiler without getting
derivation variables mixed with those of the stdenvCross.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18534
2009-11-22 22:51:45 +03:00
|
|
|
});
|
My first attempt at getting cross compilers in nixpkgs.
My idea is to provide special stdenv expressions that will contain in the path
additional cross compilers. As most expressions for programs accept a stdenv parameter,
we could substitute this parameter with the special stdenv, which will have a
generic builder that attempts the usual "--target=..." and can additionally
have an env variable like "cross" with the target architecture set.
So, finally we could have additional expressions like this:
bashRealArm = makeOverridable (import ../shells/bash) {
inherit fetchurl bison;
stdenv = stdenvCross "armv5tel-unknown-linux-gnueabi";
};
Meanwhile it does not work - I still cannot get the cross-gcc to build.
I think it does not fill the previous expressions with a lot of noise, so I
think it may be a good path to follow.
I only touched some files of the current stdenv: gcc-4.3, kernel headers
2.6.28, glibc 2.9, ...
I tried to use the gcc-cross-wrapper, that may be very outdated. Maybe I will
update it, or update the gcc-wrapper expression to make it fit the cross tools,
but meanwhile I even cannot build gcc, so I have not tested the wrapper.
This new idea on cross compiling is not similar to that of the
nixpkgs/branches/cross-compilation, which mostly added bare new expressions for
anything to be cross compiled, if I understood it correctly.
I cared not to break anything of the usual stdenv in all this work.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18343
2009-11-14 11:11:30 +03:00
|
|
|
|
2011-09-21 10:18:23 +04:00
|
|
|
bison = bison25;
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
bison1875 = callPackage ../development/tools/parsing/bison/bison-1.875.nix { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
bison23 = callPackage ../development/tools/parsing/bison/bison-2.3.nix { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
bison24 = callPackage ../development/tools/parsing/bison/bison-2.4.nix { };
|
2008-11-03 21:25:17 +03:00
|
|
|
|
2011-07-18 12:36:01 +04:00
|
|
|
bison25 = callPackage ../development/tools/parsing/bison/bison-2.5.nix { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
buildbot = callPackage ../development/tools/build-managers/buildbot {
|
2010-01-11 20:00:46 +03:00
|
|
|
inherit (pythonPackages) twisted;
|
2008-09-01 19:11:09 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
byacc = callPackage ../development/tools/parsing/byacc { };
|
2008-08-07 00:39:01 +04:00
|
|
|
|
2011-10-14 11:47:20 +04:00
|
|
|
cbrowser = callPackage ../development/tools/misc/cbrowser { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ccache = callPackage ../development/tools/misc/ccache { };
|
2008-02-12 16:32:37 +03:00
|
|
|
|
2012-01-21 04:25:30 +04:00
|
|
|
# Wrapper that works as gcc or g++
|
|
|
|
# It can be used by setting in nixpkgs config like this, for example:
|
2012-01-21 15:22:13 +04:00
|
|
|
# replaceStdenv = { pkgs }: pkgs.ccacheStdenv;
|
2012-01-21 04:25:30 +04:00
|
|
|
# But if you build in chroot, you should have that path in chroot
|
2012-01-21 05:29:06 +04:00
|
|
|
# If instantiated directly, it will use the HOME/.ccache as cache directory.
|
2012-01-21 15:22:13 +04:00
|
|
|
# You can use an override in packageOverrides to set extraConfig:
|
|
|
|
# packageOverrides = pkgs: {
|
|
|
|
# ccacheWrapper = pkgs.ccacheWrapper.override {
|
|
|
|
# extraConfig = ''
|
|
|
|
# CCACHE_COMPRESS=1
|
|
|
|
# CCACHE_DIR=/bin/.ccache
|
|
|
|
# '';
|
|
|
|
# };
|
|
|
|
#
|
|
|
|
ccacheWrapper = makeOverridable ({ extraConfig ? "" }:
|
|
|
|
wrapGCC (ccache.links extraConfig)) {};
|
|
|
|
ccacheStdenv = overrideGCC stdenv ccacheWrapper;
|
2012-01-21 04:25:30 +04:00
|
|
|
|
2011-06-05 01:46:07 +04:00
|
|
|
complexity = callPackage ../development/tools/misc/complexity { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ctags = callPackage ../development/tools/misc/ctags { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2009-05-06 20:06:45 +04:00
|
|
|
ctagsWrapped = import ../development/tools/misc/ctags/wrapped.nix {
|
2009-11-20 15:51:14 +03:00
|
|
|
inherit pkgs ctags writeScriptBin;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cmake = callPackage ../development/tools/build-managers/cmake { };
|
2007-07-08 02:31:37 +04:00
|
|
|
|
2012-02-23 15:27:43 +04:00
|
|
|
cmake264 = callPackage ../development/tools/build-managers/cmake/264.nix { };
|
|
|
|
|
2010-09-15 22:37:21 +04:00
|
|
|
cmakeCurses = cmake.override { useNcurses = true; };
|
|
|
|
|
|
|
|
cmakeWithGui = cmakeCurses.override { useQt4 = true; };
|
|
|
|
|
2012-01-16 14:20:13 +04:00
|
|
|
coccinelle = callPackage ../development/tools/misc/coccinelle {
|
|
|
|
ocamlPackages = ocamlPackages_3_12_1;
|
|
|
|
ocaml = ocaml_3_12_1;
|
|
|
|
};
|
2009-12-12 03:47:14 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cppi = callPackage ../development/tools/misc/cppi { };
|
2010-03-04 14:10:44 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cproto = callPackage ../development/tools/misc/cproto { };
|
2008-04-27 22:20:57 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cflow = callPackage ../development/tools/misc/cflow { };
|
2008-10-28 11:43:44 +03:00
|
|
|
|
2012-02-15 20:07:45 +04:00
|
|
|
cppcheck = callPackage ../development/tools/analysis/cppcheck { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cscope = callPackage ../development/tools/misc/cscope { };
|
2008-08-25 19:34:14 +04:00
|
|
|
|
2011-08-22 01:34:17 +04:00
|
|
|
csslint = callPackage ../development/web/csslint { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dejagnu = callPackage ../development/tools/misc/dejagnu { };
|
2008-04-14 15:47:26 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ddd = callPackage ../development/tools/misc/ddd { };
|
2008-07-10 20:56:51 +04:00
|
|
|
|
2010-10-26 15:14:40 +04:00
|
|
|
distcc = callPackage ../development/tools/misc/distcc { };
|
2009-10-20 15:54:49 +04:00
|
|
|
|
2009-04-12 23:34:20 +04:00
|
|
|
docutils = builderDefsPackage (import ../development/tools/documentation/docutils) {
|
|
|
|
inherit python pil makeWrapper;
|
|
|
|
};
|
|
|
|
|
2012-01-07 21:06:49 +04:00
|
|
|
doxygen = lowPrio (doxygen_gui.override { qt4 = null; });
|
2011-07-08 00:02:59 +04:00
|
|
|
|
2012-02-28 18:22:20 +04:00
|
|
|
/* XXX: The LaTeX output with Doxygen 1.8.0 makes LaTeX barf.
|
|
|
|
See <https://bugzilla.gnome.org/show_bug.cgi?id=670973>. */
|
2012-02-28 14:08:21 +04:00
|
|
|
doxygen_1_7 = callPackage ../development/tools/documentation/doxygen/1.7.nix {
|
|
|
|
qt4 = null;
|
|
|
|
};
|
|
|
|
|
2012-01-07 21:06:49 +04:00
|
|
|
doxygen_gui = callPackage ../development/tools/documentation/doxygen { };
|
2008-10-23 18:23:12 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
eggdbus = callPackage ../development/tools/misc/eggdbus { };
|
2009-08-13 11:55:11 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
elfutils = callPackage ../development/tools/misc/elfutils { };
|
2007-03-21 22:25:58 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
epm = callPackage ../development/tools/misc/epm { };
|
2007-09-06 19:00:33 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
emma = callPackage ../development/tools/analysis/emma { };
|
2008-02-26 18:48:14 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
findbugs = callPackage ../development/tools/analysis/findbugs { };
|
2008-02-25 17:55:30 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pmd = callPackage ../development/tools/analysis/pmd { };
|
2009-06-18 16:51:51 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jdepend = callPackage ../development/tools/analysis/jdepend { };
|
2009-06-18 16:51:51 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
checkstyle = callPackage ../development/tools/analysis/checkstyle { };
|
2009-06-18 16:51:51 +04:00
|
|
|
|
2010-12-13 00:48:29 +03:00
|
|
|
flex = flex2535;
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
flex2535 = callPackage ../development/tools/parsing/flex/flex-2.5.35.nix { };
|
2008-03-20 12:52:40 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
flex2534 = callPackage ../development/tools/parsing/flex/flex-2.5.34.nix { };
|
2008-02-16 22:12:55 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
flex2533 = callPackage ../development/tools/parsing/flex/flex-2.5.33.nix { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2009-11-26 02:13:28 +03:00
|
|
|
# Note: 2.5.4a is much older than 2.5.35 but happens first when sorting
|
|
|
|
# alphabetically, hence the low priority.
|
|
|
|
flex254a = lowPrio (import ../development/tools/parsing/flex/flex-2.5.4a.nix {
|
2007-12-31 01:02:04 +03:00
|
|
|
inherit fetchurl stdenv yacc;
|
2009-11-26 02:13:28 +03:00
|
|
|
});
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
m4 = gnum4;
|
2006-12-14 01:29:40 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
global = callPackage ../development/tools/misc/global { };
|
2009-07-13 13:05:56 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gnum4 = callPackage ../development/tools/misc/gnum4 { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2010-08-06 14:34:34 +04:00
|
|
|
gnumake = callPackage ../development/tools/build-managers/gnumake { };
|
2008-10-13 13:04:56 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gnumake380 = callPackage ../development/tools/build-managers/gnumake-3.80 { };
|
2010-11-09 12:14:07 +03:00
|
|
|
gnumake381 = callPackage ../development/tools/build-managers/gnumake/3.81.nix { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2012-02-05 22:29:42 +04:00
|
|
|
gob2 = callPackage ../development/tools/misc/gob2 { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gradle = callPackage ../development/tools/build-managers/gradle { };
|
2010-03-30 03:36:35 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gperf = callPackage ../development/tools/misc/gperf { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
gtkdialog = callPackage ../development/tools/misc/gtkdialog { };
|
2008-01-19 20:05:54 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
guileLint = callPackage ../development/tools/guile/guile-lint { };
|
2008-02-15 19:30:33 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gwrap = callPackage ../development/tools/guile/g-wrap { };
|
2008-04-09 11:56:52 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
help2man = callPackage ../development/tools/misc/help2man {
|
2009-04-20 16:49:35 +04:00
|
|
|
inherit (perlPackages) LocaleGettext;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2011-09-24 13:14:21 +04:00
|
|
|
hyenae = callPackage ../tools/networking/hyenae { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
iconnamingutils = callPackage ../development/tools/misc/icon-naming-utils {
|
2009-04-20 16:49:35 +04:00
|
|
|
inherit (perlPackages) XMLSimple;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2007-03-05 21:52:31 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
indent = callPackage ../development/tools/misc/indent { };
|
2007-11-25 21:35:33 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
inotifyTools = callPackage ../development/tools/misc/inotify-tools { };
|
2010-01-15 22:35:02 +03:00
|
|
|
|
2011-04-16 15:00:31 +04:00
|
|
|
intelgen4asm = callPackage ../development/misc/intelgen4asm { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ired = callPackage ../development/tools/analysis/radare/ired.nix { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2012-01-07 00:09:39 +04:00
|
|
|
itstool = callPackage ../development/tools/misc/itstool { };
|
|
|
|
|
2011-03-30 22:45:11 +04:00
|
|
|
jam = callPackage ../development/tools/build-managers/jam { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jikespg = callPackage ../development/tools/parsing/jikespg { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
lcov = callPackage ../development/tools/analysis/lcov { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2012-01-20 00:34:59 +04:00
|
|
|
leiningen = callPackage ../development/tools/build-managers/leiningen { };
|
|
|
|
|
2009-03-30 19:31:47 +04:00
|
|
|
libtool = libtool_2;
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libtool_1_5 = callPackage ../development/tools/misc/libtool { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libtool_2 = callPackage ../development/tools/misc/libtool/libtool2.nix { };
|
2008-11-03 13:15:37 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
lsof = callPackage ../development/tools/misc/lsof { };
|
2007-06-18 02:44:30 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ltrace = callPackage ../development/tools/misc/ltrace { };
|
2007-11-03 11:19:00 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mk = callPackage ../development/tools/build-managers/mk { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
noweb = callPackage ../development/tools/literate-programming/noweb { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
omake = callPackage ../development/tools/ocaml/omake { };
|
2010-05-27 23:44:03 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
openocd = callPackage ../development/tools/misc/openocd { };
|
2009-09-20 20:43:16 +04:00
|
|
|
|
2012-03-03 15:30:44 +04:00
|
|
|
oprofile = callPackage ../development/tools/profiling/oprofile { };
|
2008-06-05 01:23:30 +04:00
|
|
|
|
2010-08-06 14:34:34 +04:00
|
|
|
patchelf = callPackage ../development/tools/misc/patchelf { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2011-08-10 13:54:22 +04:00
|
|
|
peg = callPackage ../development/tools/parsing/peg { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pmccabe = callPackage ../development/tools/misc/pmccabe { };
|
2008-06-06 16:26:01 +04:00
|
|
|
|
2009-11-21 13:44:22 +03:00
|
|
|
/* Make pkgconfig always return a buildDrv, never a proper hostDrv,
|
|
|
|
because most usage of pkgconfig as buildInput (inheritance of
|
2009-11-21 18:39:20 +03:00
|
|
|
pre-cross nixpkgs) means using it using as buildNativeInput
|
|
|
|
cross_renaming: we should make all programs use pkgconfig as
|
|
|
|
buildNativeInput after the renaming.
|
|
|
|
*/
|
2010-08-06 14:34:34 +04:00
|
|
|
pkgconfig = forceBuildDrv (callPackage ../development/tools/misc/pkgconfig { });
|
2009-11-21 13:44:22 +03:00
|
|
|
|
2012-02-23 00:29:42 +04:00
|
|
|
premake = callPackage ../development/tools/misc/premake { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
radare = callPackage ../development/tools/analysis/radare {
|
2009-04-21 23:47:51 +04:00
|
|
|
inherit (gnome) vte;
|
|
|
|
lua = lua5;
|
2009-09-20 13:33:37 +04:00
|
|
|
useX11 = getConfig ["radare" "useX11"] false;
|
|
|
|
pythonBindings = getConfig ["radare" "pythonBindings"] false;
|
|
|
|
rubyBindings = getConfig ["radare" "rubyBindings"] false;
|
|
|
|
luaBindings = getConfig ["radare" "luaBindings"] false;
|
2009-04-21 23:47:51 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ragel = callPackage ../development/tools/parsing/ragel { };
|
2009-01-27 17:00:54 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
remake = callPackage ../development/tools/build-managers/remake { };
|
2009-10-11 19:03:13 +04:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
# couldn't find the source yet
|
2010-08-03 01:40:34 +04:00
|
|
|
seleniumRCBin = callPackage ../development/tools/selenium/remote-control {
|
2011-02-22 09:19:11 +03:00
|
|
|
jre = jdk;
|
|
|
|
};
|
2007-12-03 17:33:54 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
scons = callPackage ../development/tools/build-managers/scons { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
simpleBuildTool = callPackage ../development/tools/build-managers/simple-build-tool { };
|
2010-05-09 01:51:47 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
sloccount = callPackage ../development/tools/misc/sloccount { };
|
2009-02-17 13:11:33 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
sparse = callPackage ../development/tools/analysis/sparse { };
|
2008-08-22 22:33:52 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
spin = callPackage ../development/tools/analysis/spin { };
|
2009-05-03 18:35:43 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
splint = callPackage ../development/tools/analysis/splint { };
|
2008-07-11 13:13:34 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
strace = callPackage ../development/tools/misc/strace { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
swig = callPackage ../development/tools/misc/swig { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2012-01-06 03:15:24 +04:00
|
|
|
swig2 = callPackage ../development/tools/misc/swig/2.x.nix { };
|
|
|
|
|
2009-09-22 15:59:41 +04:00
|
|
|
swigWithJava = swig;
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
swftools = callPackage ../tools/video/swftools { };
|
2008-10-16 15:01:10 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
texinfo49 = callPackage ../development/tools/misc/texinfo/4.9.nix { };
|
2008-02-21 18:34:56 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
texinfo = callPackage ../development/tools/misc/texinfo { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
texi2html = callPackage ../development/tools/misc/texi2html { };
|
2009-09-10 20:57:42 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
uisp = callPackage ../development/tools/misc/uisp { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gdb = callPackage ../development/tools/misc/gdb {
|
2011-11-19 22:28:10 +04:00
|
|
|
hurd = gnu.hurdCross;
|
|
|
|
inherit (gnu) mig;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gdbCross = callPackage ../development/tools/misc/gdb {
|
2009-12-02 23:54:40 +03:00
|
|
|
target = crossSystem;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
valgrind = callPackage ../development/tools/analysis/valgrind { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2010-11-22 22:10:15 +03:00
|
|
|
valkyrie = callPackage ../development/tools/analysis/valkyrie { };
|
|
|
|
|
2012-01-08 00:23:35 +04:00
|
|
|
xxdiff = callPackage ../development/tools/misc/xxdiff { };
|
2008-05-26 00:43:56 +04:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
yacc = bison;
|
2007-09-03 16:10:57 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
yodl = callPackage ../development/tools/misc/yodl { };
|
2008-12-22 21:36:02 +03:00
|
|
|
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
### DEVELOPMENT / LIBRARIES
|
2007-02-22 19:07:51 +03:00
|
|
|
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
a52dec = callPackage ../development/libraries/a52dec { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
2012-02-23 00:29:46 +04:00
|
|
|
aacskeys = callPackage ../development/libraries/aacskeys { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
aalib = callPackage ../development/libraries/aalib { };
|
2006-06-02 13:56:10 +04:00
|
|
|
|
2010-08-06 14:34:34 +04:00
|
|
|
acl = callPackage ../development/libraries/acl { };
|
2007-12-23 18:09:12 +03:00
|
|
|
|
2011-07-22 00:58:34 +04:00
|
|
|
adns = callPackage ../development/libraries/adns { };
|
2008-06-19 02:48:34 +04:00
|
|
|
|
2011-08-02 23:46:28 +04:00
|
|
|
afflib = callPackage ../development/libraries/afflib {};
|
2008-06-19 02:48:34 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
agg = callPackage ../development/libraries/agg { };
|
2005-11-22 15:05:36 +03:00
|
|
|
|
2010-11-27 21:31:05 +03:00
|
|
|
allegro = callPackage ../development/libraries/allegro {};
|
2011-09-26 01:07:48 +04:00
|
|
|
allegro5 = callPackage ../development/libraries/allegro/5.nix {};
|
2010-11-27 21:31:05 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
amrnb = callPackage ../development/libraries/amrnb { };
|
2009-10-05 01:31:34 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
amrwb = callPackage ../development/libraries/amrwb { };
|
2009-10-05 01:31:34 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
apr = callPackage ../development/libraries/apr { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
aprutil = callPackage ../development/libraries/apr-util {
|
2007-12-31 01:02:04 +03:00
|
|
|
bdbSupport = true;
|
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2011-03-28 20:08:21 +04:00
|
|
|
asio = callPackage ../development/libraries/asio { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
aspell = callPackage ../development/libraries/aspell { };
|
2007-12-23 18:09:12 +03:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
aspellDicts = recurseIntoAttrs (import ../development/libraries/aspell/dictionaries.nix {
|
|
|
|
inherit fetchurl stdenv aspell which;
|
|
|
|
});
|
2007-12-23 18:09:12 +03:00
|
|
|
|
2009-03-19 17:34:16 +03:00
|
|
|
aterm = aterm25;
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
aterm25 = callPackage ../development/libraries/aterm/2.5.nix { };
|
2006-06-02 13:56:10 +04:00
|
|
|
|
2010-08-24 17:20:55 +04:00
|
|
|
aterm28 = lowPrio (callPackage ../development/libraries/aterm/2.8.nix { });
|
2008-01-29 12:32:56 +03:00
|
|
|
|
2011-07-08 00:47:38 +04:00
|
|
|
attica = callPackage ../development/libraries/attica { };
|
|
|
|
|
2010-08-06 14:34:34 +04:00
|
|
|
attr = callPackage ../development/libraries/attr { };
|
2004-01-25 01:50:47 +03:00
|
|
|
|
2012-01-08 23:29:07 +04:00
|
|
|
aqbanking = callPackage ../development/libraries/aqbanking { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
aubio = callPackage ../development/libraries/aubio { };
|
2009-09-21 13:58:38 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
axis = callPackage ../development/libraries/axis { };
|
2008-04-04 19:11:27 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
babl = callPackage ../development/libraries/babl { };
|
2005-05-05 03:36:28 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
beecrypt = callPackage ../development/libraries/beecrypt { };
|
2006-04-26 18:47:16 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
boehmgc = callPackage ../development/libraries/boehm-gc { };
|
2006-02-02 20:07:07 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
boolstuff = callPackage ../development/libraries/boolstuff { };
|
2009-09-10 20:57:50 +04:00
|
|
|
|
2011-05-04 14:03:46 +04:00
|
|
|
boost142 = callPackage ../development/libraries/boost/1.42.nix { };
|
2011-07-12 18:24:01 +04:00
|
|
|
boost144 = callPackage ../development/libraries/boost/1.44.nix { };
|
2011-03-04 12:48:24 +03:00
|
|
|
boost146 = callPackage ../development/libraries/boost/1.46.nix { };
|
2011-08-16 19:20:44 +04:00
|
|
|
boost147 = callPackage ../development/libraries/boost/1.47.nix { };
|
2011-11-18 18:46:29 +04:00
|
|
|
boost148 = callPackage ../development/libraries/boost/1.48.nix { };
|
2012-02-25 23:22:06 +04:00
|
|
|
boost149 = callPackage ../development/libraries/boost/1.49.nix { };
|
|
|
|
boost = boost149;
|
2006-11-14 18:55:57 +03:00
|
|
|
|
2009-04-09 12:43:46 +04:00
|
|
|
# A Boost build with all library variants enabled. Very large (about 250 MB).
|
|
|
|
boostFull = appendToName "full" (boost.override {
|
|
|
|
enableDebug = true;
|
|
|
|
enableSingleThreaded = true;
|
|
|
|
enableStatic = true;
|
|
|
|
});
|
2006-11-14 18:55:57 +03:00
|
|
|
|
2010-11-10 17:48:42 +03:00
|
|
|
botan = callPackage ../development/libraries/botan { };
|
2009-03-25 19:06:00 +03:00
|
|
|
|
2010-12-17 16:02:17 +03:00
|
|
|
box2d = callPackage ../development/libraries/box2d { };
|
2010-12-17 17:16:17 +03:00
|
|
|
box2d_2_0_1 = callPackage ../development/libraries/box2d/2.0.1.nix { };
|
2010-12-17 16:02:17 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
buddy = callPackage ../development/libraries/buddy { };
|
2008-07-15 13:58:30 +04:00
|
|
|
|
2012-02-25 00:34:35 +04:00
|
|
|
caelum = callPackage ../development/libraries/caelum { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cairomm = callPackage ../development/libraries/cairomm { };
|
2008-02-03 16:18:15 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
scmccid = callPackage ../development/libraries/scmccid { };
|
2010-01-12 22:22:22 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ccrtp = callPackage ../development/libraries/ccrtp { };
|
2011-05-31 13:09:35 +04:00
|
|
|
ccrtp_1_8 = callPackage ../development/libraries/ccrtp/1.8.nix { };
|
2009-09-20 21:01:19 +04:00
|
|
|
|
2011-06-07 18:42:24 +04:00
|
|
|
celt = callPackage ../development/libraries/celt {};
|
|
|
|
celt_0_7 = callPackage ../development/libraries/celt/0.7.nix {};
|
2009-09-20 21:01:19 +04:00
|
|
|
|
2012-01-26 22:28:53 +04:00
|
|
|
cgal = callPackage ../development/libraries/CGAL {};
|
|
|
|
|
2010-11-27 22:38:34 +03:00
|
|
|
cgui = callPackage ../development/libraries/cgui {};
|
|
|
|
|
2010-10-07 11:29:36 +04:00
|
|
|
check = callPackage ../development/libraries/check { };
|
|
|
|
|
2008-11-30 18:05:43 +03:00
|
|
|
chipmunk = builderDefsPackage (import ../development/libraries/chipmunk) {
|
|
|
|
inherit cmake freeglut mesa;
|
|
|
|
inherit (xlibs) libX11 xproto inputproto libXi libXmu;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
chmlib = callPackage ../development/libraries/chmlib { };
|
2007-05-13 18:22:24 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cil = callPackage ../development/libraries/cil { };
|
2007-10-23 20:33:11 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
cilaterm = callPackage ../development/libraries/cil-aterm {
|
2007-12-31 01:02:04 +03:00
|
|
|
stdenv = overrideInStdenv stdenv [gnumake380];
|
|
|
|
};
|
2006-02-02 20:07:07 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
clanlib = callPackage ../development/libraries/clanlib { };
|
2005-11-22 15:05:36 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
classads = callPackage ../development/libraries/classads { };
|
2010-01-27 15:12:35 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
classpath = callPackage ../development/libraries/java/classpath {
|
2009-07-31 13:59:45 +04:00
|
|
|
javac = gcj;
|
|
|
|
jvm = gcj;
|
|
|
|
gconf = gnome.GConf;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
clearsilver = callPackage ../development/libraries/clearsilver { };
|
2004-11-19 20:47:17 +03:00
|
|
|
|
2010-08-15 17:54:27 +04:00
|
|
|
cln = callPackage ../development/libraries/cln { };
|
|
|
|
|
2011-12-14 17:36:38 +04:00
|
|
|
clppcre = builderDefsPackage (import ../development/libraries/cl-ppcre) { };
|
2008-08-25 17:25:07 +04:00
|
|
|
|
2011-07-08 00:02:59 +04:00
|
|
|
clucene_core = callPackage ../development/libraries/clucene-core { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2011-07-21 15:56:11 +04:00
|
|
|
cluceneCore = clucene_core; # !!! remove this
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
clutter = callPackage ../development/libraries/clutter {
|
2010-07-19 02:45:03 +04:00
|
|
|
inherit (gnome) glib pango gtk;
|
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
clutter_gtk = callPackage ../development/libraries/clutter-gtk {
|
2010-07-19 02:45:03 +04:00
|
|
|
inherit (gnome) gtk;
|
|
|
|
};
|
|
|
|
|
2011-03-08 12:19:32 +03:00
|
|
|
cminpack = callPackage ../development/libraries/cminpack { };
|
|
|
|
|
2011-11-07 20:48:05 +04:00
|
|
|
cogl = callPackage ../development/libraries/cogl { };
|
|
|
|
|
2011-03-02 20:18:30 +03:00
|
|
|
coin3d = callPackage ../development/libraries/coin3d { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
commoncpp2 = callPackage ../development/libraries/commoncpp2 { };
|
2009-09-20 21:01:19 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
confuse = callPackage ../development/libraries/confuse { };
|
2010-07-30 03:25:42 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
consolekit = callPackage ../development/libraries/consolekit { };
|
2009-03-17 17:03:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
coredumper = callPackage ../development/libraries/coredumper { };
|
2007-06-12 19:35:57 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ctl = callPackage ../development/libraries/ctl { };
|
2004-08-23 14:44:21 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cppunit = callPackage ../development/libraries/cppunit { };
|
2005-09-12 02:39:06 +04:00
|
|
|
|
2012-01-28 00:40:44 +04:00
|
|
|
cppnetlib = callPackage ../development/libraries/cppnetlib {
|
|
|
|
boost = boostFull;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cracklib = callPackage ../development/libraries/cracklib { };
|
2005-02-27 02:45:19 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cryptopp = callPackage ../development/libraries/crypto++ { };
|
2008-07-29 18:26:03 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cyrus_sasl = callPackage ../development/libraries/cyrus-sasl { };
|
2004-01-25 02:46:00 +03:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
db4 = db45;
|
2007-07-22 22:22:46 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
db44 = callPackage ../development/libraries/db4/db4-4.4.nix { };
|
2004-08-23 21:06:50 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
db45 = callPackage ../development/libraries/db4/db4-4.5.nix { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2011-03-27 10:44:34 +04:00
|
|
|
db47 = callPackage ../development/libraries/db4/db4-4.7.nix { };
|
|
|
|
|
|
|
|
db48 = callPackage ../development/libraries/db4/db4-4.8.nix { };
|
|
|
|
|
2011-08-26 17:46:32 +04:00
|
|
|
dbus = pkgs.dbus_all.libs // { inherit (pkgs.dbus_all) libs; };
|
|
|
|
|
|
|
|
dbus_daemon = pkgs.dbus_all.daemon;
|
|
|
|
|
|
|
|
dbus_tools = pkgs.dbus_all.tools;
|
|
|
|
|
|
|
|
dbus_libs = pkgs.dbus_all.libs;
|
|
|
|
|
|
|
|
dbus_all = callPackage ../development/libraries/dbus {
|
2011-02-11 17:01:39 +03:00
|
|
|
useX11 = true;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2011-08-26 18:57:48 +04:00
|
|
|
dbus_glib = callPackage ../development/libraries/dbus-glib { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dbus_java = callPackage ../development/libraries/java/dbus-java { };
|
2010-01-02 16:28:51 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dclib = callPackage ../development/libraries/dclib { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
directfb = callPackage ../development/libraries/directfb { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2011-02-10 22:23:27 +03:00
|
|
|
dotconf = callPackage ../development/libraries/dotconf { };
|
|
|
|
|
2011-01-14 01:21:09 +03:00
|
|
|
dssi = callPackage ../development/libraries/dssi {};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
dragonegg = callPackage ../development/compilers/llvm/dragonegg.nix {
|
2010-06-12 21:42:33 +04:00
|
|
|
stdenv = overrideGCC stdenv gcc45;
|
|
|
|
};
|
|
|
|
|
2011-01-28 11:13:52 +03:00
|
|
|
eigen = callPackage ../development/libraries/eigen {};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
enchant = callPackage ../development/libraries/enchant {
|
2008-03-17 12:41:28 +03:00
|
|
|
inherit (gnome) glib;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2010-08-24 23:36:42 +04:00
|
|
|
enet = callPackage ../development/libraries/enet { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
enginepkcs11 = callPackage ../development/libraries/enginepkcs11 { };
|
2010-01-10 01:22:41 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
esdl = callPackage ../development/libraries/esdl { };
|
2010-07-01 13:08:37 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
exiv2 = callPackage ../development/libraries/exiv2 { };
|
2007-08-05 17:54:42 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
expat = callPackage ../development/libraries/expat { };
|
2004-08-10 15:07:50 +04:00
|
|
|
|
2009-02-21 21:59:15 +03:00
|
|
|
extremetuxracer = builderDefsPackage (import ../games/extremetuxracer) {
|
2009-02-27 16:44:31 +03:00
|
|
|
inherit mesa tcl freeglut SDL SDL_mixer pkgconfig
|
2010-04-12 01:03:59 +04:00
|
|
|
libpng gettext intltool;
|
2009-02-21 21:59:15 +03:00
|
|
|
inherit (xlibs) libX11 xproto libXi inputproto
|
2010-04-12 01:03:59 +04:00
|
|
|
libXmu libXext xextproto libXt libSM libICE;
|
2009-02-21 21:59:15 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
eventlog = callPackage ../development/libraries/eventlog { };
|
2009-02-05 19:50:45 +03:00
|
|
|
|
2011-06-08 01:51:00 +04:00
|
|
|
facile = callPackage ../development/libraries/facile { };
|
2007-12-06 00:25:47 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
faac = callPackage ../development/libraries/faac { };
|
2008-10-14 18:01:38 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
faad2 = callPackage ../development/libraries/faad2 { };
|
2008-10-14 18:01:38 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
farsight2 = callPackage ../development/libraries/farsight2 {
|
2010-11-17 20:03:09 +03:00
|
|
|
inherit (gst_all) gstreamer gstPluginsBase gst_python;
|
2009-12-27 18:27:45 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
fcgi = callPackage ../development/libraries/fcgi { };
|
2008-02-08 13:54:56 +03:00
|
|
|
|
2010-09-01 12:36:09 +04:00
|
|
|
ffmpeg = callPackage ../development/libraries/ffmpeg {
|
|
|
|
vpxSupport = if !stdenv.isMips then true else false;
|
|
|
|
};
|
2006-09-15 19:28:53 +04:00
|
|
|
|
2011-07-28 01:00:09 +04:00
|
|
|
ffmpeg_0_6_90 = callPackage ../development/libraries/ffmpeg/0.6.90.nix {
|
|
|
|
vpxSupport = if !stdenv.isMips then true else false;
|
2010-09-01 12:36:09 +04:00
|
|
|
};
|
2006-09-15 19:28:53 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
fftw = callPackage ../development/libraries/fftw {
|
2008-10-14 17:59:56 +04:00
|
|
|
singlePrecision = false;
|
|
|
|
};
|
2009-03-10 15:01:22 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
fftwSinglePrec = callPackage ../development/libraries/fftw {
|
2008-10-14 17:59:56 +04:00
|
|
|
singlePrecision = true;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2007-10-01 19:11:38 +04:00
|
|
|
|
2011-03-08 12:19:37 +03:00
|
|
|
flann = callPackage ../development/libraries/flann { };
|
|
|
|
|
2011-04-08 20:15:44 +04:00
|
|
|
flite = callPackage ../development/libraries/flite { };
|
|
|
|
|
2012-01-03 14:02:33 +04:00
|
|
|
fltk13 = callPackage ../development/libraries/fltk/fltk13.nix { };
|
2009-04-02 19:20:19 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
fltk20 = callPackage ../development/libraries/fltk { };
|
2006-10-13 16:58:13 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
fmod = callPackage ../development/libraries/fmod { };
|
2009-02-23 01:06:20 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
freeimage = callPackage ../development/libraries/freeimage { };
|
2009-01-13 00:12:07 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
freetts = callPackage ../development/libraries/freetts { };
|
2009-10-01 18:48:57 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cfitsio = callPackage ../development/libraries/cfitsio { };
|
2008-01-28 22:46:59 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
fontconfig = callPackage ../development/libraries/fontconfig { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
2008-07-03 18:27:19 +04:00
|
|
|
makeFontsConf = let fontconfig_ = fontconfig; in {fontconfig ? fontconfig_, fontDirectories}:
|
|
|
|
import ../development/libraries/fontconfig/make-fonts-conf.nix {
|
|
|
|
inherit runCommand libxslt fontconfig fontDirectories;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
freealut = callPackage ../development/libraries/freealut { };
|
2007-09-20 23:40:22 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
freeglut = callPackage ../development/libraries/freeglut { };
|
2007-03-05 00:28:24 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
freetype = callPackage ../development/libraries/freetype { };
|
2007-03-05 00:28:24 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
fribidi = callPackage ../development/libraries/fribidi { };
|
2004-08-24 15:26:26 +04:00
|
|
|
|
2011-03-16 02:09:27 +03:00
|
|
|
funambol = callPackage ../development/libraries/funambol { };
|
|
|
|
|
2008-01-28 22:44:39 +03:00
|
|
|
fam = gamin;
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gamin = callPackage ../development/libraries/gamin { };
|
2008-01-28 22:41:55 +03:00
|
|
|
|
2012-03-08 02:04:53 +04:00
|
|
|
gav = callPackage ../games/gav { };
|
2009-02-10 01:44:36 +03:00
|
|
|
|
2010-12-31 20:48:55 +03:00
|
|
|
gdome2 = callPackage ../development/libraries/gdome2 {
|
|
|
|
inherit (gnome) gtkdoc;
|
2009-10-28 18:06:18 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gdbm = callPackage ../development/libraries/gdbm { };
|
2008-04-07 03:18:25 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gegl = callPackage ../development/libraries/gegl {
|
2008-04-05 00:57:09 +04:00
|
|
|
# avocodec avformat librsvg
|
2008-10-10 03:21:39 +04:00
|
|
|
inherit (gtkLibs) pango glib gtk;
|
2008-04-05 00:57:09 +04:00
|
|
|
};
|
|
|
|
|
2011-01-02 16:23:59 +03:00
|
|
|
geoclue = callPackage ../development/libraries/geoclue {};
|
|
|
|
|
2009-08-26 15:13:36 +04:00
|
|
|
geoip = builderDefsPackage ../development/libraries/geoip {
|
|
|
|
inherit zlib;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
geoipjava = callPackage ../development/libraries/java/geoipjava { };
|
2010-05-06 17:58:27 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
geos = callPackage ../development/libraries/geos { };
|
2006-11-15 01:23:33 +03:00
|
|
|
|
2010-11-26 15:38:09 +03:00
|
|
|
gettext = gettext_0_18;
|
2010-05-10 16:57:10 +04:00
|
|
|
|
2010-11-26 15:34:46 +03:00
|
|
|
gettext_0_17 = callPackage ../development/libraries/gettext/0.17.nix { };
|
2010-11-26 15:38:09 +03:00
|
|
|
gettext_0_18 = callPackage ../development/libraries/gettext { };
|
2010-11-11 17:42:35 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gd = callPackage ../development/libraries/gd { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gdal = callPackage ../development/libraries/gdal { };
|
2007-10-13 00:27:15 +04:00
|
|
|
|
2011-04-17 21:55:29 +04:00
|
|
|
ggz_base_libs = callPackage ../development/libraries/ggz_base_libs {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
giblib = callPackage ../development/libraries/giblib { };
|
2009-09-03 02:56:33 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
glew = callPackage ../development/libraries/glew { };
|
2008-01-16 05:20:46 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
glfw = callPackage ../development/libraries/glfw { };
|
2009-11-30 04:05:02 +03:00
|
|
|
|
2011-10-26 14:48:55 +04:00
|
|
|
glibc = glibc213;
|
|
|
|
|
2012-02-27 01:53:18 +04:00
|
|
|
glibcCross = glibc213Cross;
|
2009-06-25 00:10:51 +04:00
|
|
|
|
2012-02-18 02:02:37 +04:00
|
|
|
glibc25 = callPackage ../development/libraries/glibc/2.5 {
|
2011-08-01 22:05:09 +04:00
|
|
|
kernelHeaders = linuxHeaders_2_6_28;
|
2010-05-19 16:25:54 +04:00
|
|
|
installLocales = false;
|
2009-06-25 00:10:51 +04:00
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2012-02-18 02:02:37 +04:00
|
|
|
glibc27 = callPackage ../development/libraries/glibc/2.7 {
|
2009-12-21 17:04:45 +03:00
|
|
|
kernelHeaders = linuxHeaders;
|
2008-10-07 20:55:20 +04:00
|
|
|
#installLocales = false;
|
|
|
|
};
|
|
|
|
|
2012-02-18 02:02:37 +04:00
|
|
|
glibc29 = callPackage ../development/libraries/glibc/2.9 {
|
2009-12-21 17:04:45 +03:00
|
|
|
kernelHeaders = linuxHeaders;
|
2011-08-24 23:33:42 +04:00
|
|
|
installLocales = getConfig [ "glibc" "locales" ] false;
|
2008-10-07 20:55:20 +04:00
|
|
|
};
|
2008-07-08 03:11:53 +04:00
|
|
|
|
2012-02-18 02:02:37 +04:00
|
|
|
glibc29Cross = forceBuildDrv (makeOverridable (import ../development/libraries/glibc/2.9) {
|
Big fixes in the cross build:
- Before this changes, cflags and ldflags for the native and the cross compiler
got mixed. Not all the gcc-wrapper/gcc-cross-wrapper variables are
independant now, but enough, I think.
- Fixed the generic stdenv expression, which did a big mess on buildInputs and
buildNativeInputs. Now it distinguishes when there is a stdenvCross or not.
Maybe we should have a single stdenv and forget about the stdenvCross
adapter - this could end in a stdenv a bit complex, but simpler than the
generic stdenv + adapter.
- Added basic support in pkgconfig for cross-builds: a single PKG_CONFIG_PATH
now works for both the cross and the native compilers, but I think this
should work well for most cases I can think of.
- I tried to fix the guile expression to cross-biuld; guile is built, but not
its manual, so the derivation still fails. Guile requires patching to
cross-build, as far as I understnad.
- Made the glibcCross build to be done through the usage of a
gcc-cross-wrapper over the gcc-cross-stage-static, instead of using it
directly.
- Trying to make physfs (a neverball dependency) cross build.
- Updated the gcc expression to support building a cross compiler without getting
derivation variables mixed with those of the stdenvCross.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18534
2009-11-22 22:51:45 +03:00
|
|
|
inherit stdenv fetchurl;
|
2010-03-07 02:36:55 +03:00
|
|
|
gccCross = gccCrossStageStatic;
|
|
|
|
kernelHeaders = linuxHeadersCross;
|
2011-08-24 23:33:42 +04:00
|
|
|
installLocales = getConfig [ "glibc" "locales" ] false;
|
Big fixes in the cross build:
- Before this changes, cflags and ldflags for the native and the cross compiler
got mixed. Not all the gcc-wrapper/gcc-cross-wrapper variables are
independant now, but enough, I think.
- Fixed the generic stdenv expression, which did a big mess on buildInputs and
buildNativeInputs. Now it distinguishes when there is a stdenvCross or not.
Maybe we should have a single stdenv and forget about the stdenvCross
adapter - this could end in a stdenv a bit complex, but simpler than the
generic stdenv + adapter.
- Added basic support in pkgconfig for cross-builds: a single PKG_CONFIG_PATH
now works for both the cross and the native compilers, but I think this
should work well for most cases I can think of.
- I tried to fix the guile expression to cross-biuld; guile is built, but not
its manual, so the derivation still fails. Guile requires patching to
cross-build, as far as I understnad.
- Made the glibcCross build to be done through the usage of a
gcc-cross-wrapper over the gcc-cross-stage-static, instead of using it
directly.
- Trying to make physfs (a neverball dependency) cross build.
- Updated the gcc expression to support building a cross compiler without getting
derivation variables mixed with those of the stdenvCross.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18534
2009-11-22 22:51:45 +03:00
|
|
|
});
|
|
|
|
|
2012-02-18 02:02:37 +04:00
|
|
|
glibc213 = (callPackage ../development/libraries/glibc/2.13 {
|
2011-10-26 14:48:55 +04:00
|
|
|
kernelHeaders = linuxHeaders;
|
|
|
|
installLocales = getConfig [ "glibc" "locales" ] false;
|
|
|
|
machHeaders = null;
|
|
|
|
hurdHeaders = null;
|
|
|
|
gccCross = null;
|
|
|
|
}) // (if crossSystem != null then { hostDrv = glibc213Cross; } else {});
|
|
|
|
|
2012-02-18 02:02:37 +04:00
|
|
|
glibc213Cross = forceBuildDrv (makeOverridable (import ../development/libraries/glibc/2.13)
|
|
|
|
(let crossGNU = crossSystem != null && crossSystem.config == "i586-pc-gnu";
|
|
|
|
in {
|
2011-10-26 14:48:55 +04:00
|
|
|
inherit stdenv fetchurl;
|
|
|
|
gccCross = gccCrossStageStatic;
|
2011-11-02 02:10:51 +04:00
|
|
|
kernelHeaders = if crossGNU then gnu.hurdHeaders else linuxHeadersCross;
|
2011-10-26 14:48:55 +04:00
|
|
|
installLocales = getConfig [ "glibc" "locales" ] false;
|
|
|
|
}
|
2012-02-18 02:02:37 +04:00
|
|
|
// lib.optionalAttrs crossGNU {
|
2011-11-02 02:10:51 +04:00
|
|
|
inherit (gnu) machHeaders hurdHeaders libpthreadHeaders mig;
|
|
|
|
inherit fetchgit;
|
2012-02-18 02:02:37 +04:00
|
|
|
}));
|
2011-10-26 14:48:55 +04:00
|
|
|
|
2012-02-18 02:02:37 +04:00
|
|
|
glibc214 = (callPackage ../development/libraries/glibc/2.14 {
|
2009-12-21 17:04:45 +03:00
|
|
|
kernelHeaders = linuxHeaders;
|
2011-08-24 23:33:42 +04:00
|
|
|
installLocales = getConfig [ "glibc" "locales" ] false;
|
2010-07-29 22:55:16 +04:00
|
|
|
machHeaders = null;
|
|
|
|
hurdHeaders = null;
|
|
|
|
gccCross = null;
|
2012-02-18 02:02:37 +04:00
|
|
|
}) // (lib.optionalAttrs (crossSystem != null) { hostDrv = glibc214Cross; });
|
2009-11-20 02:28:45 +03:00
|
|
|
|
2012-02-18 02:02:37 +04:00
|
|
|
glibc214Cross = forceBuildDrv (makeOverridable (import ../development/libraries/glibc/2.14)
|
2010-05-13 00:49:57 +04:00
|
|
|
(let crossGNU = (crossSystem != null && crossSystem.config == "i586-pc-gnu");
|
2012-02-18 02:02:37 +04:00
|
|
|
in {
|
2010-05-12 19:46:51 +04:00
|
|
|
inherit stdenv fetchurl;
|
|
|
|
gccCross = gccCrossStageStatic;
|
2012-02-18 00:37:31 +04:00
|
|
|
kernelHeaders = if crossGNU then gnu.hurdHeaders else linuxHeadersCross;
|
2011-08-24 23:33:42 +04:00
|
|
|
installLocales = getConfig [ "glibc" "locales" ] false;
|
2010-05-12 19:46:51 +04:00
|
|
|
}
|
2012-02-18 02:02:37 +04:00
|
|
|
// lib.optionalAttrs crossGNU {
|
2012-02-18 00:37:31 +04:00
|
|
|
inherit (gnu) machHeaders hurdHeaders libpthreadHeaders mig;
|
|
|
|
inherit fetchgit;
|
2012-02-18 02:02:37 +04:00
|
|
|
}));
|
2009-11-20 11:27:59 +03:00
|
|
|
|
2009-12-04 16:35:58 +03:00
|
|
|
# We can choose:
|
2010-03-09 18:48:25 +03:00
|
|
|
libcCrossChooser = name : if (name == "glibc") then glibcCross
|
|
|
|
else if (name == "uclibc") then uclibcCross
|
2010-05-06 23:19:22 +04:00
|
|
|
else if (name == "msvcrt") then windows.mingw_headers3
|
2010-03-09 18:48:25 +03:00
|
|
|
else throw "Unknown libc";
|
|
|
|
|
2010-03-09 21:17:30 +03:00
|
|
|
libcCross = assert crossSystem != null; libcCrossChooser crossSystem.libc;
|
My first attempt at getting cross compilers in nixpkgs.
My idea is to provide special stdenv expressions that will contain in the path
additional cross compilers. As most expressions for programs accept a stdenv parameter,
we could substitute this parameter with the special stdenv, which will have a
generic builder that attempts the usual "--target=..." and can additionally
have an env variable like "cross" with the target architecture set.
So, finally we could have additional expressions like this:
bashRealArm = makeOverridable (import ../shells/bash) {
inherit fetchurl bison;
stdenv = stdenvCross "armv5tel-unknown-linux-gnueabi";
};
Meanwhile it does not work - I still cannot get the cross-gcc to build.
I think it does not fill the previous expressions with a lot of noise, so I
think it may be a good path to follow.
I only touched some files of the current stdenv: gcc-4.3, kernel headers
2.6.28, glibc 2.9, ...
I tried to use the gcc-cross-wrapper, that may be very outdated. Maybe I will
update it, or update the gcc-wrapper expression to make it fit the cross tools,
but meanwhile I even cannot build gcc, so I have not tested the wrapper.
This new idea on cross compiling is not similar to that of the
nixpkgs/branches/cross-compilation, which mostly added bare new expressions for
anything to be cross compiled, if I understood it correctly.
I cared not to break anything of the usual stdenv in all this work.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18343
2009-11-14 11:11:30 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
eglibc = callPackage ../development/libraries/eglibc {
|
2009-12-21 17:04:45 +03:00
|
|
|
kernelHeaders = linuxHeaders;
|
2011-08-24 23:33:42 +04:00
|
|
|
installLocales = getConfig [ "glibc" "locales" ] false;
|
2009-11-08 03:32:12 +03:00
|
|
|
};
|
|
|
|
|
2012-03-07 12:18:00 +04:00
|
|
|
glibcLocales = callPackage ../development/libraries/glibc/2.13/locales.nix { };
|
2009-04-19 19:28:37 +04:00
|
|
|
|
2012-03-07 12:18:00 +04:00
|
|
|
glibcInfo = callPackage ../development/libraries/glibc/2.13/info.nix { };
|
2009-10-18 19:15:39 +04:00
|
|
|
|
2008-06-27 22:26:19 +04:00
|
|
|
glibc_multi =
|
2009-08-25 09:46:48 +04:00
|
|
|
runCommand "${glibc.name}-multi"
|
|
|
|
{ glibc64 = glibc;
|
|
|
|
glibc32 = (import ./all-packages.nix {system = "i686-linux";}).glibc;
|
|
|
|
}
|
|
|
|
''
|
2012-01-19 00:16:00 +04:00
|
|
|
mkdir -p $out
|
2009-08-25 09:46:48 +04:00
|
|
|
ln -s $glibc64/* $out/
|
|
|
|
|
|
|
|
rm $out/lib $out/lib64
|
2012-01-19 00:16:00 +04:00
|
|
|
mkdir -p $out/lib
|
2009-08-25 09:46:48 +04:00
|
|
|
ln -s $glibc64/lib/* $out/lib
|
|
|
|
ln -s $glibc32/lib $out/lib/32
|
|
|
|
ln -s lib $out/lib64
|
|
|
|
|
|
|
|
rm $out/include
|
|
|
|
cp -rs $glibc32/include $out
|
|
|
|
chmod -R u+w $out/include
|
|
|
|
cp -rsf $glibc64/include $out
|
|
|
|
'' # */
|
2009-08-28 10:29:21 +04:00
|
|
|
;
|
2008-06-27 22:26:19 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
glpk = callPackage ../development/libraries/glpk { };
|
2010-04-24 01:15:48 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gmime = callPackage ../development/libraries/gmime { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gmm = callPackage ../development/libraries/gmm { };
|
2008-04-21 19:20:49 +04:00
|
|
|
|
2010-03-12 02:25:03 +03:00
|
|
|
gmp =
|
2010-11-10 18:05:18 +03:00
|
|
|
if stdenv.system == "i686-darwin" then
|
2010-02-08 20:46:34 +03:00
|
|
|
# GMP 4.3.2 is broken on Darwin, so use 4.3.1.
|
2011-12-14 18:31:56 +04:00
|
|
|
callPackage ../development/libraries/gmp/4.3.1.nix { }
|
2010-03-16 15:13:40 +03:00
|
|
|
else
|
2012-02-07 03:03:12 +04:00
|
|
|
callPackage ../development/libraries/gmp/5.0.3.nix { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2011-12-21 13:28:17 +04:00
|
|
|
gmpxx = appendToName "with-cxx" (gmp.override { cxx = true; });
|
2009-07-03 15:31:28 +04:00
|
|
|
|
2012-01-18 22:43:34 +04:00
|
|
|
# The GHC bootstrap binaries link against libgmp.so.3, which is in GMP 4.x.
|
2012-02-07 03:03:12 +04:00
|
|
|
gmp4 =
|
|
|
|
if stdenv.system == "i686-darwin" then
|
|
|
|
# GMP 4.3.2 is broken on Darwin, so use 4.3.1.
|
|
|
|
callPackage ../development/libraries/gmp/4.3.1.nix { }
|
|
|
|
else
|
|
|
|
callPackage ../development/libraries/gmp/4.3.2.nix { };
|
2012-03-07 02:27:14 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gobjectIntrospection = callPackage ../development/libraries/gobject-introspection { };
|
2010-05-13 19:56:04 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
goffice = callPackage ../development/libraries/goffice {
|
2009-09-30 17:11:13 +04:00
|
|
|
inherit (gnome) glib gtk libglade libgnomeui pango;
|
|
|
|
gconf = gnome.GConf;
|
|
|
|
libart = gnome.libart_lgpl;
|
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
goocanvas = callPackage ../development/libraries/goocanvas {
|
2008-12-02 15:28:13 +03:00
|
|
|
inherit (gnome) gtk glib;
|
|
|
|
};
|
|
|
|
|
2011-09-27 21:24:01 +04:00
|
|
|
google_perftools = callPackage ../development/libraries/google-perftools { };
|
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
#GMP ex-satellite, so better keep it near gmp
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mpfr = callPackage ../development/libraries/mpfr { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2010-10-11 02:34:48 +04:00
|
|
|
gst_all = recurseIntoAttrs
|
|
|
|
(let callPackage = newScope pkgs.gst_all; in
|
2011-07-07 21:26:31 +04:00
|
|
|
import ../development/libraries/gstreamer { inherit callPackage; }
|
|
|
|
);
|
2008-02-22 06:06:12 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gnet = callPackage ../development/libraries/gnet { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2012-03-14 05:23:31 +04:00
|
|
|
gnu_efi = callPackage ../development/libraries/gnu-efi {
|
|
|
|
stdenv = overrideInStdenv stdenv [gnumake381];
|
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gnutls = callPackage ../development/libraries/gnutls {
|
2009-04-30 22:43:48 +04:00
|
|
|
guileBindings = getConfig ["gnutls" "guile"] true;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2011-08-27 21:04:25 +04:00
|
|
|
gnutls2 = callPackage ../development/libraries/gnutls/2.12.nix {
|
|
|
|
guileBindings = getConfig ["gnutls" "guile"] true;
|
|
|
|
};
|
|
|
|
|
2012-02-05 03:21:33 +04:00
|
|
|
gnutls_without_guile = gnutls.override { guileBindings = false; };
|
|
|
|
gnutls2_without_guile = gnutls2.override { guileBindings = false; };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gpgme = callPackage ../development/libraries/gpgme { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2010-09-03 21:40:55 +04:00
|
|
|
grantlee = callPackage ../development/libraries/grantlee { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gsasl = callPackage ../development/libraries/gsasl { };
|
2010-04-26 12:59:25 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gsl = callPackage ../development/libraries/gsl { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2011-06-07 18:42:24 +04:00
|
|
|
gsm = callPackage ../development/libraries/gsm {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gsoap = callPackage ../development/libraries/gsoap { };
|
2010-01-27 15:12:35 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gss = callPackage ../development/libraries/gss { };
|
2010-04-26 12:59:25 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gtkimageview = callPackage ../development/libraries/gtkimageview {
|
2009-10-19 16:50:41 +04:00
|
|
|
inherit (gnome) gtk;
|
|
|
|
};
|
|
|
|
|
2010-12-31 20:48:55 +03:00
|
|
|
gtkmathview = callPackage ../development/libraries/gtkmathview { };
|
|
|
|
|
2012-02-05 22:29:42 +04:00
|
|
|
gtkLibs = {
|
|
|
|
inherit (pkgs) glib glibmm atk atkmm cairo pango pangomm gdk_pixbuf gtk
|
|
|
|
gtkmm;
|
|
|
|
};
|
2009-11-03 18:57:22 +03:00
|
|
|
|
2012-02-05 22:29:42 +04:00
|
|
|
glib = callPackage ../development/libraries/glib/2.28.x.nix { };
|
2009-01-23 01:32:02 +03:00
|
|
|
|
2012-02-05 22:29:42 +04:00
|
|
|
glibmm = callPackage ../development/libraries/glibmm/2.28.x.nix { };
|
2009-10-29 13:53:54 +03:00
|
|
|
|
2012-03-08 20:49:08 +04:00
|
|
|
glib_networking = callPackage ../development/libraries/glib-networking {};
|
|
|
|
|
2012-02-05 22:29:42 +04:00
|
|
|
atk = callPackage ../development/libraries/atk/2.2.x.nix { };
|
2009-10-29 13:53:54 +03:00
|
|
|
|
2012-02-05 22:29:42 +04:00
|
|
|
atkmm = callPackage ../development/libraries/atkmm/2.22.x.nix { };
|
2009-10-29 13:53:54 +03:00
|
|
|
|
2012-02-05 22:29:42 +04:00
|
|
|
cairo = callPackage ../development/libraries/cairo { };
|
2009-10-29 13:53:54 +03:00
|
|
|
|
2012-03-09 03:25:52 +04:00
|
|
|
pango = callPackage ../development/libraries/pango/1.29.x.nix { };
|
2009-10-29 13:53:54 +03:00
|
|
|
|
2012-02-05 22:29:42 +04:00
|
|
|
pangomm = callPackage ../development/libraries/pangomm/2.28.x.nix { };
|
2009-09-29 17:49:41 +04:00
|
|
|
|
2012-02-05 22:29:42 +04:00
|
|
|
gdk_pixbuf = callPackage ../development/libraries/gdk-pixbuf/2.24.x.nix { };
|
2010-07-19 03:22:59 +04:00
|
|
|
|
2012-02-08 01:03:16 +04:00
|
|
|
gtk2 = callPackage ../development/libraries/gtk+/2.24.x.nix { };
|
2010-07-19 03:22:59 +04:00
|
|
|
|
2012-02-08 01:03:16 +04:00
|
|
|
gtk = pkgs.gtk2;
|
2010-07-19 03:22:59 +04:00
|
|
|
|
2012-02-08 01:03:16 +04:00
|
|
|
gtkmm = callPackage ../development/libraries/gtkmm/2.24.x.nix { };
|
2011-04-06 14:00:48 +04:00
|
|
|
|
2012-02-08 01:03:16 +04:00
|
|
|
gtk3 = lowPrio (callPackage ../development/libraries/gtk+/3.2.x.nix { });
|
2009-09-29 17:49:41 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gtkmozembedsharp = callPackage ../development/libraries/gtkmozembed-sharp {
|
2007-12-31 01:02:04 +03:00
|
|
|
inherit (gnome) gtk;
|
|
|
|
gtksharp = gtksharp2;
|
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gtksharp1 = callPackage ../development/libraries/gtk-sharp-1 {
|
2008-06-19 02:48:34 +04:00
|
|
|
inherit (gnome) gtk glib pango libglade libgtkhtml gtkhtml
|
|
|
|
libgnomecanvas libgnomeui libgnomeprint
|
2007-12-31 01:02:04 +03:00
|
|
|
libgnomeprintui GConf;
|
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gtksharp2 = callPackage ../development/libraries/gtk-sharp-2 {
|
2008-06-19 02:48:34 +04:00
|
|
|
inherit (gnome) gtk glib pango libglade libgtkhtml gtkhtml
|
|
|
|
libgnomecanvas libgnomeui libgnomeprint
|
2007-12-31 01:02:04 +03:00
|
|
|
libgnomeprintui GConf gnomepanel;
|
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gtksourceviewsharp = callPackage ../development/libraries/gtksourceview-sharp {
|
2007-12-31 01:02:04 +03:00
|
|
|
inherit (gnome) gtksourceview;
|
|
|
|
gtksharp = gtksharp2;
|
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
gtkspell = callPackage ../development/libraries/gtkspell { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2011-03-02 20:18:15 +03:00
|
|
|
gts = callPackage ../development/libraries/gts { };
|
|
|
|
|
2012-01-08 23:29:07 +04:00
|
|
|
gwenhywfar = callPackage ../development/libraries/gwenhywfar { };
|
|
|
|
|
2008-01-28 22:44:39 +03:00
|
|
|
# TODO : Add MIT Kerberos and let admin choose.
|
|
|
|
kerberos = heimdal;
|
|
|
|
|
2011-03-26 01:15:48 +03:00
|
|
|
hawknl = callPackage ../development/libraries/hawknl { };
|
2010-12-26 20:18:13 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
heimdal = callPackage ../development/libraries/kerberos/heimdal.nix { };
|
2010-12-26 20:18:13 +03:00
|
|
|
|
2011-07-11 14:49:21 +04:00
|
|
|
herqq = callPackage ../development/libraries/herqq { };
|
2010-12-26 20:18:13 +03:00
|
|
|
|
2010-10-17 22:44:00 +04:00
|
|
|
hspell = callPackage ../development/libraries/hspell { };
|
|
|
|
|
|
|
|
hspellDicts = callPackage ../development/libraries/hspell/dicts.nix { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
hsqldb = callPackage ../development/libraries/java/hsqldb { };
|
2007-10-01 19:12:41 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
hunspell = callPackage ../development/libraries/hunspell { };
|
2010-06-30 19:53:28 +04:00
|
|
|
|
2011-12-06 18:04:01 +04:00
|
|
|
hwloc = callPackage ../development/libraries/hwloc {
|
|
|
|
inherit (xlibs) libX11;
|
|
|
|
};
|
2009-11-05 21:46:46 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
hydraAntLogger = callPackage ../development/libraries/java/hydra-ant-logger { };
|
2010-03-02 18:37:04 +03:00
|
|
|
|
2010-10-19 12:19:46 +04:00
|
|
|
icedtea = callPackage ../development/libraries/java/icedtea {
|
|
|
|
ant = apacheAntGcj;
|
|
|
|
xerces = xercesJava;
|
|
|
|
xulrunner = icecatXulrunner3;
|
|
|
|
inherit (xlibs) libX11 libXp libXtst libXinerama libXt
|
|
|
|
libXrender xproto;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
icu = callPackage ../development/libraries/icu { };
|
2004-01-25 03:50:00 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
id3lib = callPackage ../development/libraries/id3lib { };
|
2007-11-15 02:05:11 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ilbc = callPackage ../development/libraries/ilbc { };
|
2008-02-10 20:35:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ilmbase = callPackage ../development/libraries/ilmbase { };
|
2005-12-19 21:56:31 +03:00
|
|
|
|
2012-01-28 00:06:42 +04:00
|
|
|
imlib = callPackage ../development/libraries/imlib {
|
|
|
|
libpng = libpng12;
|
|
|
|
};
|
2007-10-22 04:51:40 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
imlib2 = callPackage ../development/libraries/imlib2 { };
|
2007-10-29 13:52:04 +03:00
|
|
|
|
2010-10-14 15:54:13 +04:00
|
|
|
incrtcl = callPackage ../development/libraries/incrtcl { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
indilib = callPackage ../development/libraries/indilib { };
|
2008-01-28 22:47:23 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
iniparser = callPackage ../development/libraries/iniparser { };
|
2008-01-28 22:45:19 +03:00
|
|
|
|
2008-10-09 16:12:58 +04:00
|
|
|
intltool = gnome.intltool;
|
2007-09-03 16:10:57 +04:00
|
|
|
|
2012-02-19 17:15:50 +04:00
|
|
|
irrlicht3843 = callPackage ../development/libraries/irrlicht { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
isocodes = callPackage ../development/libraries/iso-codes { };
|
2009-05-18 17:53:01 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
itk = callPackage ../development/libraries/itk { };
|
2010-03-02 02:31:35 +03:00
|
|
|
|
2009-11-19 15:10:23 +03:00
|
|
|
jamp = builderDefsPackage ../games/jamp {
|
|
|
|
inherit mesa SDL SDL_image SDL_mixer;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jasper = callPackage ../development/libraries/jasper { };
|
2009-11-03 18:57:22 +03:00
|
|
|
|
2010-10-14 15:53:59 +04:00
|
|
|
jama = callPackage ../development/libraries/jama { };
|
|
|
|
|
2010-08-10 00:59:38 +04:00
|
|
|
jbig2dec = callPackage ../development/libraries/jbig2dec { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jetty_gwt = callPackage ../development/libraries/java/jetty-gwt { };
|
2009-11-03 18:57:22 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jetty_util = callPackage ../development/libraries/java/jetty-util { };
|
2008-01-28 22:41:03 +03:00
|
|
|
|
2010-09-27 15:18:28 +04:00
|
|
|
json_glib = callPackage ../development/libraries/json-glib { };
|
|
|
|
|
2011-11-07 00:03:07 +04:00
|
|
|
json_c = callPackage ../development/libraries/json-c { };
|
|
|
|
|
2011-11-01 21:07:14 +04:00
|
|
|
libjson = callPackage ../development/libraries/libjson { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
judy = callPackage ../development/libraries/judy { };
|
2010-06-03 19:37:02 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
krb5 = callPackage ../development/libraries/kerberos/krb5.nix { };
|
2009-11-06 15:57:29 +03:00
|
|
|
|
2010-08-07 00:23:56 +04:00
|
|
|
lcms = lcms1;
|
|
|
|
|
|
|
|
lcms1 = callPackage ../development/libraries/lcms { };
|
|
|
|
|
|
|
|
lcms2 = callPackage ../development/libraries/lcms2 { };
|
2007-05-15 01:47:11 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
lensfun = callPackage ../development/libraries/lensfun {
|
2010-05-03 07:45:52 +04:00
|
|
|
inherit (gnome) glib;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
lesstif = callPackage ../development/libraries/lesstif { };
|
2007-04-18 17:47:35 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
lesstif93 = callPackage ../development/libraries/lesstif-0.93 { };
|
2008-10-06 19:11:36 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
levmar = callPackage ../development/libraries/levmar { };
|
2010-01-21 17:39:53 +03:00
|
|
|
|
2011-04-24 22:16:51 +04:00
|
|
|
leptonica = callPackage ../development/libraries/leptonica { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
lib3ds = callPackage ../development/libraries/lib3ds { };
|
2008-06-08 07:56:32 +04:00
|
|
|
|
2012-02-23 00:29:25 +04:00
|
|
|
libaacs = callPackage ../development/libraries/libaacs { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libaal = callPackage ../development/libraries/libaal { };
|
2008-02-04 17:37:15 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
libao = callPackage ../development/libraries/libao {
|
2010-02-15 20:10:35 +03:00
|
|
|
usePulseAudio = getConfig [ "pulseaudio" ] true;
|
2008-02-12 00:02:38 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libarchive = callPackage ../development/libraries/libarchive { };
|
2008-01-28 22:46:38 +03:00
|
|
|
|
2011-02-10 00:10:42 +03:00
|
|
|
libass = callPackage ../development/libraries/libass { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libassuan1 = callPackage ../development/libraries/libassuan1 { };
|
2008-01-28 22:43:37 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libassuan = callPackage ../development/libraries/libassuan { };
|
2008-01-28 22:43:37 +03:00
|
|
|
|
2011-07-15 16:20:34 +04:00
|
|
|
libav = callPackage ../development/libraries/libav { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libavc1394 = callPackage ../development/libraries/libavc1394 { };
|
2008-01-13 18:21:21 +03:00
|
|
|
|
2011-03-16 02:09:07 +03:00
|
|
|
libbluedevil = callPackage ../development/libraries/libbluedevil { };
|
|
|
|
|
2012-02-23 00:29:29 +04:00
|
|
|
libbluray = callPackage ../development/libraries/libbluray { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libcaca = callPackage ../development/libraries/libcaca { };
|
2006-01-02 17:24:36 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
libcanberra = callPackage ../development/libraries/libcanberra {
|
2011-07-17 17:27:12 +04:00
|
|
|
# gstreamer = gst_all.gstreamer;
|
2009-01-20 12:50:15 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libcdaudio = callPackage ../development/libraries/libcdaudio { };
|
2003-11-02 20:42:19 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libcddb = callPackage ../development/libraries/libcddb { };
|
2008-03-05 12:10:23 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libcdio = callPackage ../development/libraries/libcdio { };
|
2008-03-05 12:10:23 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
libchamplain = callPackage ../development/libraries/libchamplain {
|
2010-07-19 02:46:19 +04:00
|
|
|
inherit (gnome) gtk glib libsoup;
|
|
|
|
};
|
|
|
|
|
2011-11-13 18:33:31 +04:00
|
|
|
libchop = callPackage ../development/libraries/libchop { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libcm = callPackage ../development/libraries/libcm { };
|
2007-12-03 19:01:51 +03:00
|
|
|
|
2012-03-09 02:57:05 +04:00
|
|
|
libcroco = callPackage ../development/libraries/libcroco {};
|
|
|
|
|
2010-09-28 13:33:42 +04:00
|
|
|
libctemplate = callPackage ../development/libraries/libctemplate { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libcue = callPackage ../development/libraries/libcue { };
|
2010-04-18 23:12:07 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libdaemon = callPackage ../development/libraries/libdaemon { };
|
2007-09-01 22:26:13 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libdbi = callPackage ../development/libraries/libdbi { };
|
2006-06-22 01:05:39 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
libdbiDriversBase = callPackage ../development/libraries/libdbi-drivers {
|
2010-07-29 22:55:16 +04:00
|
|
|
mysql = null;
|
|
|
|
sqlite = null;
|
2009-11-18 12:39:59 +03:00
|
|
|
};
|
2007-09-04 13:38:52 +04:00
|
|
|
|
2010-07-29 12:21:21 +04:00
|
|
|
libdbiDrivers = libdbiDriversBase.override {
|
2008-02-25 06:16:07 +03:00
|
|
|
inherit sqlite mysql;
|
2008-08-15 02:04:30 +04:00
|
|
|
};
|
2003-11-03 01:25:26 +03:00
|
|
|
|
2011-06-08 01:50:23 +04:00
|
|
|
libdbusmenu_qt = callPackage ../development/libraries/libdbusmenu-qt { };
|
|
|
|
|
2010-11-13 10:47:04 +03:00
|
|
|
libdevil = callPackage ../development/libraries/libdevil { };
|
|
|
|
|
2010-09-14 18:29:13 +04:00
|
|
|
libdiscid = callPackage ../development/libraries/libdiscid { };
|
|
|
|
|
2011-06-08 01:50:23 +04:00
|
|
|
libdmtx = callPackage ../development/libraries/libdmtx { };
|
2007-08-18 20:20:14 +04:00
|
|
|
|
2011-09-24 13:14:21 +04:00
|
|
|
libdnet = callPackage ../development/libraries/libdnet { };
|
|
|
|
|
2011-08-29 22:55:37 +04:00
|
|
|
libdrm = callPackage ../development/libraries/libdrm {
|
2009-10-29 20:56:10 +03:00
|
|
|
inherit fetchurl stdenv pkgconfig;
|
|
|
|
inherit (xorg) libpthreadstubs;
|
2011-08-29 22:55:37 +04:00
|
|
|
};
|
2003-11-03 01:25:26 +03:00
|
|
|
|
2011-06-08 01:50:23 +04:00
|
|
|
libdv = callPackage ../development/libraries/libdv { };
|
|
|
|
|
2011-12-07 03:09:19 +04:00
|
|
|
libdvbpsi = callPackage ../development/libraries/libdvbpsi { };
|
|
|
|
|
2011-06-08 01:50:23 +04:00
|
|
|
libdwg = callPackage ../development/libraries/libdwg { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libdvdcss = callPackage ../development/libraries/libdvdcss { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libdvdnav = callPackage ../development/libraries/libdvdnav { };
|
2006-12-14 01:29:40 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libdvdread = callPackage ../development/libraries/libdvdread { };
|
2007-10-27 21:55:13 +04:00
|
|
|
|
2011-02-12 23:18:41 +03:00
|
|
|
libebml = callPackage ../development/libraries/libebml { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libedit = callPackage ../development/libraries/libedit { };
|
2009-04-16 23:25:22 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libelf = callPackage ../development/libraries/libelf { };
|
2010-04-28 16:36:58 +04:00
|
|
|
|
2011-06-08 01:50:23 +04:00
|
|
|
libgadu = callPackage ../development/libraries/libgadu { };
|
|
|
|
|
|
|
|
libgdata = (newScope gnome) ../development/libraries/libgdata {};
|
|
|
|
libgdata_0_6 = (newScope gnome) ../development/libraries/libgdata/0.6.nix {};
|
|
|
|
|
2012-03-08 17:06:44 +04:00
|
|
|
libgnome_keyring = callPackage ../development/libraries/libgnome-keyring { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
liblo = callPackage ../development/libraries/liblo { };
|
2009-09-21 13:58:27 +04:00
|
|
|
|
2011-01-14 01:21:09 +03:00
|
|
|
liblrdf = callPackage ../development/libraries/liblrdf {};
|
|
|
|
|
2009-08-27 11:17:57 +04:00
|
|
|
libev = builderDefsPackage ../development/libraries/libev {
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libevent = callPackage ../development/libraries/libevent { };
|
2004-01-22 22:09:49 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libewf = callPackage ../development/libraries/libewf { };
|
2009-04-21 23:47:41 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libexif = callPackage ../development/libraries/libexif { };
|
2007-11-08 20:48:52 +03:00
|
|
|
|
2011-01-13 23:49:58 +03:00
|
|
|
libexosip = callPackage ../development/libraries/exosip {};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
libextractor = callPackage ../development/libraries/libextractor {
|
2010-01-05 14:16:30 +03:00
|
|
|
inherit (gnome) gtk;
|
|
|
|
libmpeg2 = mpeg2dec;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2006-03-14 21:20:21 +03:00
|
|
|
|
2011-03-03 16:41:06 +03:00
|
|
|
libf2c = callPackage ../development/libraries/libf2c {};
|
|
|
|
|
2010-10-25 09:52:13 +04:00
|
|
|
libfixposix = callPackage ../development/libraries/libfixposix {};
|
|
|
|
|
2009-05-31 10:07:25 +04:00
|
|
|
libffcall = builderDefsPackage (import ../development/libraries/libffcall) {
|
|
|
|
inherit fetchcvs;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libffi = callPackage ../development/libraries/libffi { };
|
2008-04-09 11:40:48 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libftdi = callPackage ../development/libraries/libftdi { };
|
2009-09-25 01:28:27 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libgcrypt = callPackage ../development/libraries/libgcrypt { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
2012-03-06 17:49:37 +04:00
|
|
|
libgdiplus = callPackage ../development/libraries/libgdiplus { };
|
2012-01-04 17:55:54 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libgpgerror = callPackage ../development/libraries/libgpg-error { };
|
2003-11-05 15:17:48 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libgphoto2 = callPackage ../development/libraries/libgphoto2 { };
|
2005-01-20 00:12:46 +03:00
|
|
|
|
2010-09-26 23:40:22 +04:00
|
|
|
libgpod = callPackage ../development/libraries/libgpod {
|
|
|
|
inherit (pkgs.pythonPackages) mutagen;
|
|
|
|
};
|
2009-04-13 19:41:00 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libharu = callPackage ../development/libraries/libharu { };
|
2009-09-13 12:54:44 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libical = callPackage ../development/libraries/libical { };
|
2009-02-27 16:44:31 +03:00
|
|
|
|
2010-09-26 23:40:07 +04:00
|
|
|
libimobiledevice = callPackage ../development/libraries/libimobiledevice { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
libiodbc = callPackage ../development/libraries/libiodbc {
|
2011-08-24 23:33:42 +04:00
|
|
|
useGTK = getConfig [ "libiodbc" "gtk" ] false;
|
2010-04-06 14:50:52 +04:00
|
|
|
};
|
2010-04-03 13:53:38 +04:00
|
|
|
|
2010-09-26 23:40:15 +04:00
|
|
|
liblastfmSF = callPackage ../development/libraries/liblastfmSF { };
|
|
|
|
|
|
|
|
liblastfm = callPackage ../development/libraries/liblastfm { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
liblqr1 = callPackage ../development/libraries/liblqr-1 {
|
2010-05-03 07:45:47 +04:00
|
|
|
inherit (gnome) glib;
|
|
|
|
};
|
|
|
|
|
2010-08-24 12:24:33 +04:00
|
|
|
libmhash = callPackage ../development/libraries/libmhash {};
|
|
|
|
|
2010-09-26 23:39:28 +04:00
|
|
|
libmtp = callPackage ../development/libraries/libmtp { };
|
|
|
|
|
2012-02-02 02:32:12 +04:00
|
|
|
libnatspec = callPackage ../development/libraries/libnatspec { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
libnice = callPackage ../development/libraries/libnice {
|
2012-03-13 23:06:24 +04:00
|
|
|
inherit (gst_all) gstreamer gstPluginsBase;
|
2009-12-27 17:22:00 +03:00
|
|
|
};
|
|
|
|
|
2010-10-03 13:25:34 +04:00
|
|
|
libplist = callPackage ../development/libraries/libplist { };
|
2010-09-26 23:39:21 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libQGLViewer = callPackage ../development/libraries/libqglviewer { };
|
2008-06-08 07:56:32 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libsamplerate = callPackage ../development/libraries/libsamplerate { };
|
2005-01-20 00:48:45 +03:00
|
|
|
|
2011-07-11 18:47:15 +04:00
|
|
|
libspectre = callPackage ../development/libraries/libspectre { };
|
2008-07-17 23:43:11 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
libgsf = callPackage ../development/libraries/libgsf {
|
2011-10-08 16:06:03 +04:00
|
|
|
inherit (gnome) glib gnome_vfs libbonobo;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2005-01-20 00:48:45 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libiconv = callPackage ../development/libraries/libiconv { };
|
2009-09-20 02:03:24 +04:00
|
|
|
|
2012-01-28 16:44:42 +04:00
|
|
|
libiconvOrNull = if gcc ? libc then null else libiconv;
|
|
|
|
|
|
|
|
libiconvOrLibc = if gcc ? libc then gcc.libc else libiconv;
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libid3tag = callPackage ../development/libraries/libid3tag { };
|
2008-02-12 00:02:38 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libidn = callPackage ../development/libraries/libidn { };
|
2006-01-07 20:25:39 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libiec61883 = callPackage ../development/libraries/libiec61883 { };
|
2008-01-13 18:21:21 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
libinfinity = callPackage ../development/libraries/libinfinity {
|
2010-06-21 20:06:18 +04:00
|
|
|
inherit (gnome) gtkdoc;
|
|
|
|
};
|
2010-07-26 17:41:09 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libiptcdata = callPackage ../development/libraries/libiptcdata { };
|
2010-01-17 03:46:57 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libjingle = callPackage ../development/libraries/libjingle/0.3.11.nix { };
|
2008-02-21 02:02:41 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libjpeg = callPackage ../development/libraries/libjpeg { };
|
2005-11-23 01:32:18 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libjpeg_turbo = callPackage ../development/libraries/libjpeg-turbo { };
|
2010-07-10 12:45:44 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
libjpeg62 = callPackage ../development/libraries/libjpeg/62.nix {
|
2010-01-04 10:47:32 +03:00
|
|
|
libtool = libtool_1_5;
|
|
|
|
};
|
|
|
|
|
2011-02-10 00:10:55 +03:00
|
|
|
libkate = callPackage ../development/libraries/libkate { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libksba = callPackage ../development/libraries/libksba { };
|
2008-01-28 22:44:20 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libmad = callPackage ../development/libraries/libmad { };
|
2005-10-27 01:10:31 +04:00
|
|
|
|
2010-08-10 02:40:51 +04:00
|
|
|
libmatchbox = callPackage ../development/libraries/libmatchbox {
|
|
|
|
inherit (gtkLibs) pango;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libmatthew_java = callPackage ../development/libraries/java/libmatthew-java { };
|
2010-01-02 16:28:51 +03:00
|
|
|
|
2011-02-12 23:18:46 +03:00
|
|
|
libmatroska = callPackage ../development/libraries/libmatroska { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libmcs = callPackage ../development/libraries/libmcs { };
|
2008-03-03 13:55:20 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libmicrohttpd = callPackage ../development/libraries/libmicrohttpd { };
|
2008-05-11 15:46:48 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libmikmod = callPackage ../development/libraries/libmikmod { };
|
2010-04-18 22:57:35 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libmilter = callPackage ../development/libraries/libmilter { };
|
2010-02-09 13:32:55 +03:00
|
|
|
|
2011-08-15 22:04:57 +04:00
|
|
|
libmms = callPackage ../development/libraries/libmms { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libmowgli = callPackage ../development/libraries/libmowgli { };
|
2008-03-03 13:55:20 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libmng = callPackage ../development/libraries/libmng { };
|
2009-09-13 12:54:41 +04:00
|
|
|
|
2011-09-11 20:45:42 +04:00
|
|
|
libmodplug = callPackage ../development/libraries/libmodplug {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libmpcdec = callPackage ../development/libraries/libmpcdec { };
|
2005-10-27 01:10:31 +04:00
|
|
|
|
2010-12-31 00:23:19 +03:00
|
|
|
libmrss = callPackage ../development/libraries/libmrss { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libmsn = callPackage ../development/libraries/libmsn { };
|
2009-02-27 16:44:31 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libmspack = callPackage ../development/libraries/libmspack { };
|
2003-11-06 18:24:19 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libmusclecard = callPackage ../development/libraries/libmusclecard { };
|
2010-01-09 21:06:37 +03:00
|
|
|
|
2010-09-14 18:29:19 +04:00
|
|
|
libmusicbrainz2 = callPackage ../development/libraries/libmusicbrainz/2.x.nix { };
|
|
|
|
|
|
|
|
libmusicbrainz3 = callPackage ../development/libraries/libmusicbrainz { };
|
|
|
|
|
|
|
|
libmusicbrainz = libmusicbrainz3;
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libnih = callPackage ../development/libraries/libnih { };
|
2010-02-15 18:55:39 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libnova = callPackage ../development/libraries/libnova { };
|
2008-01-28 22:47:12 +03:00
|
|
|
|
2010-12-31 00:23:19 +03:00
|
|
|
libnxml = callPackage ../development/libraries/libnxml { };
|
|
|
|
|
2010-09-14 18:29:25 +04:00
|
|
|
libofa = callPackage ../development/libraries/libofa { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libofx = callPackage ../development/libraries/libofx { };
|
2010-01-27 01:04:54 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libogg = callPackage ../development/libraries/libogg { };
|
2003-11-25 21:02:05 +03:00
|
|
|
|
2011-02-10 00:10:28 +03:00
|
|
|
liboggz = callPackage ../development/libraries/liboggz { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
liboil = callPackage ../development/libraries/liboil { };
|
2008-02-22 06:06:12 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
liboop = callPackage ../development/libraries/liboop { };
|
2008-02-12 13:51:44 +03:00
|
|
|
|
2010-08-31 13:58:09 +04:00
|
|
|
libosip = callPackage ../development/libraries/osip {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libotr = callPackage ../development/libraries/libotr { };
|
2007-05-13 18:22:24 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libp11 = callPackage ../development/libraries/libp11 { };
|
2010-01-10 01:22:41 +03:00
|
|
|
|
2011-04-30 13:21:38 +04:00
|
|
|
libpar2 = callPackage ../development/libraries/libpar2 { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libpcap = callPackage ../development/libraries/libpcap { };
|
2007-09-06 19:56:39 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libpng = callPackage ../development/libraries/libpng { };
|
2010-10-08 09:58:00 +04:00
|
|
|
libpng_apng = callPackage ../development/libraries/libpng/libpng-apng.nix { };
|
2012-01-08 23:50:06 +04:00
|
|
|
libpng12 = callPackage ../development/libraries/libpng/12.nix { };
|
2007-08-08 17:20:18 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libproxy = callPackage ../development/libraries/libproxy { };
|
2009-06-25 17:37:59 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libpseudo = callPackage ../development/libraries/libpseudo { };
|
2009-04-23 01:33:24 +04:00
|
|
|
|
2010-08-15 17:55:02 +04:00
|
|
|
libqalculate = callPackage ../development/libraries/libqalculate { };
|
|
|
|
|
2012-03-09 02:57:05 +04:00
|
|
|
librsvg = callPackage ../development/libraries/librsvg { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
librsync = callPackage ../development/libraries/librsync { };
|
2010-02-04 16:42:41 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libsigcxx = callPackage ../development/libraries/libsigcxx { };
|
2003-11-05 15:17:48 +03:00
|
|
|
|
2010-08-29 13:43:46 +04:00
|
|
|
libsigcxx12 = callPackage ../development/libraries/libsigcxx/1.2.nix { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libsigsegv = callPackage ../development/libraries/libsigsegv { };
|
2007-03-05 16:44:27 +03:00
|
|
|
|
2009-08-10 09:20:14 +04:00
|
|
|
# To bootstrap SBCL, I need CLisp 2.44.1; it needs libsigsegv 2.5
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libsigsegv_25 = callPackage ../development/libraries/libsigsegv/2.5.nix { };
|
2009-08-10 09:20:14 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libsndfile = callPackage ../development/libraries/libsndfile { };
|
2010-03-04 17:44:56 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libssh = callPackage ../development/libraries/libssh { };
|
2010-03-16 15:13:40 +03:00
|
|
|
|
2010-08-06 00:24:32 +04:00
|
|
|
libssh2 = callPackage ../development/libraries/libssh2 { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libstartup_notification = callPackage ../development/libraries/startup-notification { };
|
2008-05-20 18:25:09 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libtasn1 = callPackage ../development/libraries/libtasn1 { };
|
2007-11-05 11:32:20 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libtheora = callPackage ../development/libraries/libtheora { };
|
2007-08-10 12:21:31 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libtiff = callPackage ../development/libraries/libtiff { };
|
2008-08-12 23:57:35 +04:00
|
|
|
|
2011-02-10 00:11:16 +03:00
|
|
|
libtiger = callPackage ../development/libraries/libtiger { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libtommath = callPackage ../development/libraries/libtommath { };
|
2010-06-03 04:51:13 +04:00
|
|
|
|
2010-11-13 10:47:04 +03:00
|
|
|
libtorrentRasterbar = callPackage ../development/libraries/libtorrent-rasterbar { };
|
|
|
|
|
2010-09-14 18:29:37 +04:00
|
|
|
libtunepimp = callPackage ../development/libraries/libtunepimp { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libgeotiff = callPackage ../development/libraries/libgeotiff { };
|
2009-06-28 01:44:47 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libunistring = callPackage ../development/libraries/libunistring { };
|
2008-10-08 01:18:01 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libupnp = callPackage ../development/libraries/pupnp { };
|
2008-01-01 00:52:43 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
giflib = callPackage ../development/libraries/giflib { };
|
2003-11-06 18:24:19 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libungif = callPackage ../development/libraries/giflib/libungif.nix { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libusb = callPackage ../development/libraries/libusb { };
|
2008-01-28 22:45:30 +03:00
|
|
|
|
2010-09-26 23:39:02 +04:00
|
|
|
libusb1 = callPackage ../development/libraries/libusb1 { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libunwind = callPackage ../development/libraries/libunwind { };
|
2010-03-03 13:37:38 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libv4l = callPackage ../development/libraries/libv4l { };
|
|
|
|
|
2011-04-16 15:00:31 +04:00
|
|
|
libva = callPackage ../development/libraries/libva { };
|
|
|
|
|
2010-12-27 21:30:52 +03:00
|
|
|
libvdpau = callPackage ../development/libraries/libvdpau { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libvirt = callPackage ../development/libraries/libvirt { };
|
2010-01-27 15:12:35 +03:00
|
|
|
|
2008-10-04 19:24:08 +04:00
|
|
|
libvncserver = builderDefsPackage (import ../development/libraries/libvncserver) {
|
|
|
|
inherit libtool libjpeg openssl zlib;
|
2008-10-09 14:10:49 +04:00
|
|
|
inherit (xlibs) xproto libX11 damageproto libXdamage
|
2008-10-04 19:24:08 +04:00
|
|
|
libXext xextproto fixesproto libXfixes xineramaproto
|
|
|
|
libXinerama libXrandr randrproto libXtst;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libviper = callPackage ../development/libraries/libviper { };
|
2009-04-23 01:33:24 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libvpx = callPackage ../development/libraries/libvpx { };
|
2010-05-25 01:57:45 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libvterm = callPackage ../development/libraries/libvterm { };
|
2009-11-05 01:38:26 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libvorbis = callPackage ../development/libraries/libvorbis { };
|
2006-07-08 16:44:39 +04:00
|
|
|
|
2012-02-09 01:37:20 +04:00
|
|
|
libwebp = callPackage ../development/libraries/libwebp { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libwmf = callPackage ../development/libraries/libwmf { };
|
2003-11-06 18:24:19 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
libwpd = callPackage ../development/libraries/libwpd {
|
2007-12-31 01:02:04 +03:00
|
|
|
inherit (gnome) glib;
|
|
|
|
};
|
2007-02-28 20:52:41 +03:00
|
|
|
|
2012-01-07 17:19:06 +04:00
|
|
|
libwpd_08 = callPackage ../development/libraries/libwpd/0.8.nix {
|
|
|
|
inherit (gnome) glib;
|
|
|
|
};
|
|
|
|
|
2010-09-22 22:04:41 +04:00
|
|
|
libwpg = callPackage ../development/libraries/libwpg { };
|
|
|
|
|
2009-10-24 23:58:07 +04:00
|
|
|
libx86 = builderDefsPackage ../development/libraries/libx86 {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libxcrypt = callPackage ../development/libraries/libxcrypt { };
|
2007-08-06 22:45:53 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libxdg_basedir = callPackage ../development/libraries/libxdg-basedir { };
|
2010-03-04 17:44:56 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libxklavier = callPackage ../development/libraries/libxklavier { };
|
2008-02-18 23:53:36 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libxmi = callPackage ../development/libraries/libxmi { };
|
2009-04-06 01:41:38 +04:00
|
|
|
|
2012-02-28 04:07:12 +04:00
|
|
|
libxml2 = callPackage ../development/libraries/libxml2 {
|
|
|
|
pythonSupport = false;
|
|
|
|
};
|
2007-12-01 19:20:23 +03:00
|
|
|
|
2012-02-28 04:07:12 +04:00
|
|
|
libxml2Python = libxml2.override {
|
|
|
|
pythonSupport = true;
|
|
|
|
};
|
2007-12-01 19:20:23 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
libxmlxx = callPackage ../development/libraries/libxmlxx {
|
2010-06-26 05:40:42 +04:00
|
|
|
inherit (gtkLibs) glibmm;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libxslt = callPackage ../development/libraries/libxslt { };
|
2007-12-01 19:20:23 +03:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
libixp_for_wmii = lowPrio (import ../development/libraries/libixp_for_wmii {
|
|
|
|
inherit fetchurl stdenv;
|
|
|
|
});
|
2007-12-01 19:20:23 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libyaml = callPackage ../development/libraries/libyaml { };
|
2010-01-16 13:37:29 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libzip = callPackage ../development/libraries/libzip { };
|
2006-07-25 12:44:05 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libzrtpcpp = callPackage ../development/libraries/libzrtpcpp { };
|
2011-05-31 13:09:35 +04:00
|
|
|
libzrtpcpp_1_6 = callPackage ../development/libraries/libzrtpcpp/1.6.nix {
|
|
|
|
ccrtp = ccrtp_1_8;
|
|
|
|
};
|
2009-09-20 21:01:19 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
lightning = callPackage ../development/libraries/lightning { };
|
2008-07-01 18:47:49 +04:00
|
|
|
|
2012-01-09 14:25:49 +04:00
|
|
|
lirc = callPackage ../development/libraries/lirc { };
|
|
|
|
|
2009-12-16 19:06:30 +03:00
|
|
|
liquidwar = builderDefsPackage ../games/liquidwar {
|
|
|
|
inherit (xlibs) xproto libX11 libXrender;
|
2011-02-17 01:21:07 +03:00
|
|
|
inherit gmp mesa libjpeg libpng
|
2009-12-16 19:06:30 +03:00
|
|
|
expat gettext perl
|
|
|
|
SDL SDL_image SDL_mixer SDL_ttf
|
|
|
|
curl sqlite
|
|
|
|
libogg libvorbis
|
|
|
|
;
|
2011-02-17 01:21:07 +03:00
|
|
|
guile = guile_1_8;
|
2009-12-16 19:06:30 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
log4cxx = callPackage ../development/libraries/log4cxx { };
|
2003-11-06 18:24:19 +03:00
|
|
|
|
2011-12-06 19:05:57 +04:00
|
|
|
log4cplus = callPackage ../development/libraries/log4cplus { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
loudmouth = callPackage ../development/libraries/loudmouth { };
|
2008-01-28 22:49:25 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
lzo = callPackage ../development/libraries/lzo { };
|
2003-11-06 18:24:19 +03:00
|
|
|
|
2008-03-03 13:55:20 +03:00
|
|
|
# failed to build
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mediastreamer = callPackage ../development/libraries/mediastreamer { };
|
2008-02-07 12:43:10 +03:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
mesaSupported =
|
|
|
|
system == "i686-linux" ||
|
2009-09-16 19:12:24 +04:00
|
|
|
system == "x86_64-linux" ||
|
2009-12-03 01:19:49 +03:00
|
|
|
system == "x86_64-darwin" ||
|
2009-09-16 19:12:24 +04:00
|
|
|
system == "i686-darwin";
|
2008-06-19 02:48:34 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
mesa = callPackage ../development/libraries/mesa {
|
2010-04-29 18:56:52 +04:00
|
|
|
lipo = if stdenv.isDarwin then darwinLipoUtility else null;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2003-11-06 18:24:19 +03:00
|
|
|
|
2010-08-24 17:20:55 +04:00
|
|
|
metaEnvironment = recurseIntoAttrs (let callPackage = newScope pkgs.metaEnvironment; in rec {
|
|
|
|
sdfLibrary = callPackage ../development/libraries/sdf-library { aterm = aterm28; };
|
|
|
|
toolbuslib = callPackage ../development/libraries/toolbuslib { aterm = aterm28; inherit (windows) w32api; };
|
|
|
|
cLibrary = callPackage ../development/libraries/c-library { aterm = aterm28; };
|
|
|
|
errorSupport = callPackage ../development/libraries/error-support { aterm = aterm28; };
|
|
|
|
ptSupport = callPackage ../development/libraries/pt-support { aterm = aterm28; };
|
|
|
|
ptableSupport = callPackage ../development/libraries/ptable-support { aterm = aterm28; };
|
|
|
|
configSupport = callPackage ../development/libraries/config-support { aterm = aterm28; };
|
|
|
|
asfSupport = callPackage ../development/libraries/asf-support { aterm = aterm28; };
|
|
|
|
tideSupport = callPackage ../development/libraries/tide-support { aterm = aterm28; };
|
|
|
|
rstoreSupport = callPackage ../development/libraries/rstore-support { aterm = aterm28; };
|
|
|
|
sdfSupport = callPackage ../development/libraries/sdf-support { aterm = aterm28; };
|
|
|
|
sglr = callPackage ../development/libraries/sglr { aterm = aterm28; };
|
|
|
|
ascSupport = callPackage ../development/libraries/asc-support { aterm = aterm28; };
|
|
|
|
pgen = callPackage ../development/libraries/pgen { aterm = aterm28; };
|
|
|
|
});
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ming = callPackage ../development/libraries/ming { };
|
2008-09-02 17:43:53 +04:00
|
|
|
|
2011-02-12 23:18:53 +03:00
|
|
|
mkvtoolnix = callPackage ../applications/video/mkvtoolnix { };
|
|
|
|
|
2012-01-07 21:06:49 +04:00
|
|
|
mlt = callPackage ../development/libraries/mlt { };
|
2010-04-30 17:12:07 +04:00
|
|
|
|
2011-07-25 23:07:36 +04:00
|
|
|
libmpeg2 = callPackage ../development/libraries/libmpeg2 { };
|
|
|
|
|
|
|
|
mpeg2dec = libmpeg2;
|
2006-08-13 13:46:54 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
msilbc = callPackage ../development/libraries/msilbc { };
|
2008-02-10 20:35:03 +03:00
|
|
|
|
2010-09-14 18:29:31 +04:00
|
|
|
mp4v2 = callPackage ../development/libraries/mp4v2 { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mpc = callPackage ../development/libraries/mpc { };
|
2010-04-28 16:36:53 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mpich2 = callPackage ../development/libraries/mpich2 { };
|
2008-02-21 19:17:43 +03:00
|
|
|
|
2011-08-08 04:25:38 +04:00
|
|
|
mtdev = callPackage ../development/libraries/mtdev { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
muparser = callPackage ../development/libraries/muparser { };
|
2009-05-13 14:21:29 +04:00
|
|
|
|
2011-03-31 02:08:33 +04:00
|
|
|
mygui = callPackage ../development/libraries/mygui {};
|
|
|
|
|
|
|
|
myguiSvn = callPackage ../development/libraries/mygui/svn.nix {};
|
|
|
|
|
2012-02-25 01:13:14 +04:00
|
|
|
mysocketw = callPackage ../development/libraries/mysocketw { };
|
|
|
|
|
2010-07-29 12:21:21 +04:00
|
|
|
ncurses = makeOverridable (import ../development/libraries/ncurses) {
|
2009-11-20 11:27:59 +03:00
|
|
|
inherit fetchurl stdenv;
|
2010-10-12 23:06:04 +04:00
|
|
|
unicode = system != "i686-cygwin";
|
I made the whole nixpkgs dependencies available to the cross compiler, no
needing to keep a new tree of expressions apart for the expressions to get
cross-compiled.
I changed the whole way of using cross compilation with nixpkgs, which before
was done through a simple adapter.
Now the adapter became complex, and I've tried to avoid the most obvious
recursivities. For example, the fetchurl expression should
never be cross-compiled, as the gmp, mpfr, and some others, like
some ncurses, perl, ... I made overrided copies of those necessary as
perlNoCross, ncursesNoCross, as stdenvNoCross, keeping in mind that
the stdenv (capable of cross compilation) is built upon stdenvNoCross using
an adapter.
So, to cross compile, instead of building using "nixpkgs/default.nix",
you should build with your
own "myarchiteture.nix", which should have contents like these, for example:
import /etc/nixos/nixpkgs/default.nix
{
crossSystem = {
config = "armv5tel-unknown-linux-gnueabi";
bigEndian = false;
arch = "arm";
float = "soft";
};
}
svn path=/nixpkgs/branches/stdenv-updates/; revision=18398
2009-11-18 01:58:48 +03:00
|
|
|
};
|
|
|
|
|
2010-04-28 12:40:19 +04:00
|
|
|
neon = neon029;
|
2008-06-19 19:29:25 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
neon026 = callPackage ../development/libraries/neon/0.26.nix {
|
2008-06-19 19:29:25 +04:00
|
|
|
compressionSupport = true;
|
|
|
|
sslSupport = true;
|
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
neon028 = callPackage ../development/libraries/neon/0.28.nix {
|
2007-12-31 01:02:04 +03:00
|
|
|
compressionSupport = true;
|
|
|
|
sslSupport = true;
|
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
neon029 = callPackage ../development/libraries/neon/0.29.nix {
|
2007-12-31 01:02:04 +03:00
|
|
|
compressionSupport = true;
|
|
|
|
sslSupport = true;
|
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2009-05-12 08:28:30 +04:00
|
|
|
nethack = builderDefsPackage (import ../games/nethack) {
|
|
|
|
inherit ncurses flex bison;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
nettle = callPackage ../development/libraries/nettle { };
|
2009-07-01 19:42:01 +04:00
|
|
|
|
2012-01-06 20:45:14 +04:00
|
|
|
newt = callPackage ../development/libraries/newt { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
nspr = callPackage ../development/libraries/nspr { };
|
2009-07-04 16:25:35 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
nss = callPackage ../development/libraries/nss { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2010-08-11 19:49:42 +04:00
|
|
|
nssTools = callPackage ../development/libraries/nss {
|
2010-08-11 13:38:09 +04:00
|
|
|
includeTools = true;
|
|
|
|
};
|
|
|
|
|
2011-06-08 01:50:48 +04:00
|
|
|
ntrack = callPackage ../development/libraries/ntrack { };
|
|
|
|
|
2008-11-30 19:50:05 +03:00
|
|
|
ode = builderDefsPackage (import ../development/libraries/ode) {
|
|
|
|
};
|
2011-02-24 14:25:16 +03:00
|
|
|
|
2010-12-22 17:50:13 +03:00
|
|
|
ogre = callPackage ../development/libraries/ogre {};
|
2008-11-30 19:50:05 +03:00
|
|
|
|
2012-02-25 01:13:14 +04:00
|
|
|
ogrepaged = callPackage ../development/libraries/ogrepaged { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
openal = callPackage ../development/libraries/openal { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
# added because I hope that it has been easier to compile on x86 (for blender)
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
openalSoft = callPackage ../development/libraries/openal-soft { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
openbabel = callPackage ../development/libraries/openbabel { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2012-03-02 17:47:37 +04:00
|
|
|
opencascade = callPackage ../development/libraries/opencascade {
|
|
|
|
ftgl = ftgl212;
|
|
|
|
};
|
2009-01-27 11:14:27 +03:00
|
|
|
|
2012-01-26 22:28:53 +04:00
|
|
|
opencsg = callPackage ../development/libraries/opencsg { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
openct = callPackage ../development/libraries/openct { };
|
2010-01-10 03:22:29 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
opencv = callPackage ../development/libraries/opencv {
|
2011-08-01 16:03:16 +04:00
|
|
|
ffmpeg = ffmpeg_0_6_90;
|
|
|
|
inherit (gst_all) gstreamer;
|
2010-01-17 00:26:10 +03:00
|
|
|
};
|
|
|
|
|
2011-08-05 20:13:20 +04:00
|
|
|
opencv_2_1 = callPackage ../development/libraries/opencv/2.1.nix {
|
|
|
|
ffmpeg = ffmpeg_0_6_90;
|
2012-01-27 21:55:41 +04:00
|
|
|
libpng = libpng12;
|
2011-08-05 20:13:20 +04:00
|
|
|
inherit (gst_all) gstreamer;
|
2010-01-17 00:26:10 +03:00
|
|
|
};
|
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
# this ctl version is needed by openexr_viewers
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
openexr_ctl = callPackage ../development/libraries/openexr_ctl { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
openexr = callPackage ../development/libraries/openexr { };
|
2008-06-19 02:48:34 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
openldap = callPackage ../development/libraries/openldap { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2009-08-08 22:18:33 +04:00
|
|
|
openlierox = builderDefsPackage ../games/openlierox {
|
|
|
|
inherit (xlibs) libX11 xproto;
|
2009-09-23 00:16:38 +04:00
|
|
|
inherit gd SDL SDL_image SDL_mixer zlib libxml2
|
2009-08-08 22:18:33 +04:00
|
|
|
pkgconfig;
|
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
libopensc_dnie = callPackage ../development/libraries/libopensc-dnie {
|
2010-01-10 03:22:29 +03:00
|
|
|
opensc = opensc_0_11_7;
|
|
|
|
};
|
|
|
|
|
2010-12-22 13:47:12 +03:00
|
|
|
ois = callPackage ../development/libraries/ois {};
|
|
|
|
|
2010-09-06 03:37:54 +04:00
|
|
|
opal = callPackage ../development/libraries/opal {};
|
|
|
|
|
2010-08-10 00:59:38 +04:00
|
|
|
openjpeg = callPackage ../development/libraries/openjpeg { };
|
|
|
|
|
2011-04-09 20:43:00 +04:00
|
|
|
openscenegraph = callPackage ../development/libraries/openscenegraph {};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
openssl = callPackage ../development/libraries/openssl {
|
2008-05-27 11:49:55 +04:00
|
|
|
fetchurl = fetchurlBoot;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ortp = callPackage ../development/libraries/ortp { };
|
2008-01-28 22:49:08 +03:00
|
|
|
|
2011-11-07 20:48:14 +04:00
|
|
|
p11_kit = callPackage ../development/libraries/p11-kit { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
pangoxsl = callPackage ../development/libraries/pangoxsl {
|
2007-12-31 01:02:04 +03:00
|
|
|
inherit (gtkLibs) glib pango;
|
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
pcre = callPackage ../development/libraries/pcre {
|
2011-12-14 17:36:38 +04:00
|
|
|
unicodeSupport = getConfig ["pcre" "unicode"] true;
|
2007-11-21 22:28:54 +03:00
|
|
|
cplusplusSupport = !stdenv ? isDietLibC;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2007-12-01 19:20:23 +03:00
|
|
|
|
2010-08-25 18:25:51 +04:00
|
|
|
pdf2xml = callPackage ../development/libraries/pdf2xml {} ;
|
|
|
|
|
2011-07-28 16:20:12 +04:00
|
|
|
phonon = callPackage ../development/libraries/phonon { };
|
|
|
|
|
|
|
|
phonon_backend_gstreamer = callPackage ../development/libraries/phonon-backend-gstreamer { };
|
|
|
|
|
2012-01-07 19:31:27 +04:00
|
|
|
phonon_backend_vlc = callPackage ../development/libraries/phonon-backend-vlc { };
|
2010-08-04 14:04:40 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
physfs = callPackage ../development/libraries/physfs { };
|
2009-11-06 22:25:45 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
plib = callPackage ../development/libraries/plib { };
|
2008-10-12 18:27:51 +04:00
|
|
|
|
2011-04-04 22:50:39 +04:00
|
|
|
pocketsphinx = callPackage ../development/libraries/pocketsphinx { };
|
|
|
|
|
2010-09-17 23:14:47 +04:00
|
|
|
podofo = callPackage ../development/libraries/podofo { };
|
2010-01-08 01:47:30 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
polkit = callPackage ../development/libraries/polkit { };
|
2009-08-13 11:55:11 +04:00
|
|
|
|
2011-07-08 00:47:38 +04:00
|
|
|
polkit_qt_1 = callPackage ../development/libraries/polkit-qt-1 { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
policykit = callPackage ../development/libraries/policykit { };
|
2009-08-17 22:31:42 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
poppler = callPackage ../development/libraries/poppler {
|
2011-07-11 17:04:38 +04:00
|
|
|
gtkSupport = true;
|
2009-09-13 15:04:54 +04:00
|
|
|
qt4Support = false;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2007-08-17 01:45:10 +04:00
|
|
|
|
2010-04-12 01:03:51 +04:00
|
|
|
popplerQt4 = poppler.override {
|
2011-07-11 17:04:38 +04:00
|
|
|
gtkSupport = false;
|
2009-09-13 15:04:54 +04:00
|
|
|
qt4Support = true;
|
2010-02-10 18:06:50 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
popt = callPackage ../development/libraries/popt { };
|
2006-08-13 13:46:54 +04:00
|
|
|
|
2010-08-22 16:08:55 +04:00
|
|
|
portaudio = callPackage ../development/libraries/portaudio { };
|
2011-01-02 20:13:34 +03:00
|
|
|
portaudioSVN = callPackage ../development/libraries/portaudio/svn-head.nix { };
|
2010-08-22 16:08:55 +04:00
|
|
|
|
2011-08-15 22:05:16 +04:00
|
|
|
prison = callPackage ../development/libraries/prison { };
|
2010-08-22 16:08:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
proj = callPackage ../development/libraries/proj { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
postgis = callPackage ../development/libraries/postgis { };
|
2010-05-10 00:38:16 +04:00
|
|
|
|
2010-10-31 01:44:22 +04:00
|
|
|
protobuf = callPackage ../development/libraries/protobuf { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pth = callPackage ../development/libraries/pth { };
|
2008-01-28 22:43:03 +03:00
|
|
|
|
2010-09-06 03:37:54 +04:00
|
|
|
ptlib = callPackage ../development/libraries/ptlib {};
|
|
|
|
|
2011-02-22 12:53:01 +03:00
|
|
|
qca2 = callPackage ../development/libraries/qca2 {};
|
|
|
|
|
|
|
|
qca2_ossl = callPackage ../development/libraries/qca2/ossl.nix {};
|
|
|
|
|
2011-02-22 14:54:42 +03:00
|
|
|
qimageblitz = callPackage ../development/libraries/qimageblitz {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
qjson = callPackage ../development/libraries/qjson { };
|
2010-07-05 00:59:47 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
qt3 = callPackage ../development/libraries/qt-3 {
|
2007-12-31 01:02:04 +03:00
|
|
|
openglSupport = mesaSupported;
|
2008-06-23 13:01:04 +04:00
|
|
|
};
|
|
|
|
|
2010-10-10 11:39:01 +04:00
|
|
|
qt4 = pkgs.kde4.qt4;
|
2009-09-13 15:04:54 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
qt47 = callPackage ../development/libraries/qt-4.x/4.7 {
|
2010-08-19 02:53:42 +04:00
|
|
|
inherit (pkgs.gnome) glib;
|
2010-05-08 00:08:37 +04:00
|
|
|
};
|
|
|
|
|
2011-12-25 01:52:08 +04:00
|
|
|
qt48 = callPackage ../development/libraries/qt-4.x/4.8 {
|
|
|
|
# GNOME dependencies are not used unless gtkStyle == true
|
|
|
|
inherit (pkgs.gnome) gtk libgnomeui GConf gnome_vfs;
|
|
|
|
# GStreamer is required for HTML5 video in QtWebKit
|
|
|
|
inherit (pkgs.gst_all) gstreamer gstPluginsBase;
|
|
|
|
};
|
|
|
|
|
2010-08-19 02:53:42 +04:00
|
|
|
qtscriptgenerator = callPackage ../development/libraries/qtscriptgenerator { };
|
2009-09-23 00:16:38 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
quesoglc = callPackage ../development/libraries/quesoglc { };
|
2010-05-03 19:38:16 +04:00
|
|
|
|
2011-08-11 13:35:10 +04:00
|
|
|
qwt = callPackage ../development/libraries/qwt {};
|
|
|
|
|
2009-02-24 00:18:55 +03:00
|
|
|
readline = readline6;
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
readline4 = callPackage ../development/libraries/readline/readline4.nix { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
readline5 = callPackage ../development/libraries/readline/readline5.nix { };
|
2006-04-03 17:02:05 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
readline6 = callPackage ../development/libraries/readline/readline6.nix { };
|
2009-02-23 21:10:41 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
librdf_raptor = callPackage ../development/libraries/librdf/raptor.nix { };
|
2010-03-16 15:13:40 +03:00
|
|
|
|
2011-07-11 14:49:21 +04:00
|
|
|
librdf_raptor2 = callPackage ../development/libraries/librdf/raptor2.nix { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
librdf_rasqal = callPackage ../development/libraries/librdf/rasqal.nix { };
|
2010-03-16 15:13:40 +03:00
|
|
|
|
2011-08-15 22:04:51 +04:00
|
|
|
librdf_redland = callPackage ../development/libraries/librdf/redland.nix { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
librdf = callPackage ../development/libraries/librdf { };
|
2009-09-21 13:58:21 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
qrupdate = callPackage ../development/libraries/qrupdate { };
|
2009-09-21 13:58:21 +04:00
|
|
|
|
2011-08-15 22:04:51 +04:00
|
|
|
redland = pkgs.librdf_redland;
|
2010-02-10 18:06:50 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
rhino = callPackage ../development/libraries/java/rhino {
|
2009-10-19 18:47:04 +04:00
|
|
|
ant = apacheAntGcj;
|
|
|
|
javac = gcj;
|
|
|
|
jvm = gcj;
|
|
|
|
};
|
|
|
|
|
2010-11-28 12:59:13 +03:00
|
|
|
rlog = callPackage ../development/libraries/rlog { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
rubberband = callPackage ../development/libraries/rubberband {
|
2009-09-21 13:58:30 +04:00
|
|
|
fftw = fftwSinglePrec;
|
|
|
|
inherit (vamp) vampSDK;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
schroedinger = callPackage ../development/libraries/schroedinger { };
|
2008-03-10 23:13:44 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
SDL = callPackage ../development/libraries/SDL {
|
2010-11-08 00:55:01 +03:00
|
|
|
openglSupport = mesaSupported;
|
2007-12-31 01:02:04 +03:00
|
|
|
alsaSupport = true;
|
2010-11-08 00:17:23 +03:00
|
|
|
x11Support = true;
|
2009-08-12 02:23:30 +04:00
|
|
|
pulseaudioSupport = false; # better go through ALSA
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2006-11-26 02:41:53 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
SDL_gfx = callPackage ../development/libraries/SDL_gfx { };
|
2010-05-02 13:27:45 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
SDL_image = callPackage ../development/libraries/SDL_image { };
|
2004-08-23 13:35:36 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
SDL_mixer = callPackage ../development/libraries/SDL_mixer { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
SDL_net = callPackage ../development/libraries/SDL_net { };
|
2008-02-07 00:26:17 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
SDL_sound = callPackage ../development/libraries/SDL_sound { };
|
2010-07-08 01:44:09 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
SDL_ttf = callPackage ../development/libraries/SDL_ttf { };
|
2005-03-11 13:46:20 +03:00
|
|
|
|
2011-04-09 20:43:00 +04:00
|
|
|
simgear = callPackage ../development/libraries/simgear {};
|
|
|
|
|
2011-04-29 00:50:12 +04:00
|
|
|
sfml_git = callPackage ../development/libraries/sfml { };
|
2011-03-20 21:21:37 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
slang = callPackage ../development/libraries/slang { };
|
2005-03-11 13:55:21 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
slibGuile = callPackage ../development/libraries/slib {
|
2011-07-09 16:11:36 +04:00
|
|
|
scheme = guile_1_8;
|
2009-09-30 17:10:58 +04:00
|
|
|
};
|
|
|
|
|
2011-03-28 22:58:49 +04:00
|
|
|
smpeg = callPackage ../development/libraries/smpeg { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
snack = callPackage ../development/libraries/snack {
|
2008-09-24 04:42:06 +04:00
|
|
|
# optional
|
|
|
|
};
|
|
|
|
|
2011-09-27 19:40:40 +04:00
|
|
|
soprano = callPackage ../development/libraries/soprano { };
|
|
|
|
|
2012-02-22 19:02:21 +04:00
|
|
|
soqt = callPackage ../development/libraries/soqt { };
|
2011-03-02 20:18:30 +03:00
|
|
|
|
2011-02-10 22:23:27 +03:00
|
|
|
speechd = callPackage ../development/libraries/speechd { };
|
|
|
|
|
2011-05-25 13:04:54 +04:00
|
|
|
speech_tools = callPackage ../development/libraries/speech-tools {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
speex = callPackage ../development/libraries/speex { };
|
2007-08-17 01:45:10 +04:00
|
|
|
|
2011-04-04 22:50:23 +04:00
|
|
|
sphinxbase = callPackage ../development/libraries/sphinxbase { };
|
|
|
|
|
2010-09-06 03:37:54 +04:00
|
|
|
srtp = callPackage ../development/libraries/srtp {};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
sqlite = callPackage ../development/libraries/sqlite {
|
2010-07-30 17:05:52 +04:00
|
|
|
readline = null;
|
|
|
|
ncurses = null;
|
2010-07-30 16:31:10 +04:00
|
|
|
};
|
2010-02-04 19:07:15 +03:00
|
|
|
|
2010-08-06 12:54:27 +04:00
|
|
|
sqlite36 = callPackage ../development/libraries/sqlite/3.6.x.nix {
|
|
|
|
readline = null;
|
|
|
|
ncurses = null;
|
|
|
|
};
|
|
|
|
|
2010-08-04 15:42:10 +04:00
|
|
|
sqliteInteractive = appendToName "interactive" (sqlite.override {
|
2010-07-30 17:05:52 +04:00
|
|
|
inherit readline ncurses;
|
2010-08-04 15:42:10 +04:00
|
|
|
});
|
2006-04-22 22:08:37 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
stlport = callPackage ../development/libraries/stlport { };
|
2008-09-05 21:17:00 +04:00
|
|
|
|
2011-02-22 14:54:49 +03:00
|
|
|
strigi = callPackage ../development/libraries/strigi {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
suitesparse = callPackage ../development/libraries/suitesparse { };
|
2010-08-02 15:20:39 +04:00
|
|
|
|
2010-11-03 23:36:36 +03:00
|
|
|
sword = callPackage ../development/libraries/sword { };
|
|
|
|
|
2010-11-19 16:24:11 +03:00
|
|
|
szip = callPackage ../development/libraries/szip { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
t1lib = callPackage ../development/libraries/t1lib { };
|
2005-03-11 14:02:31 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
taglib = callPackage ../development/libraries/taglib { };
|
2010-10-04 13:49:25 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
taglib_extras = callPackage ../development/libraries/taglib-extras { };
|
2009-09-11 16:05:23 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
talloc = callPackage ../development/libraries/talloc { };
|
2010-05-27 23:33:28 +04:00
|
|
|
|
2012-02-10 14:13:34 +04:00
|
|
|
tclap = callPackage ../development/libraries/tclap {};
|
|
|
|
|
2011-08-29 16:47:39 +04:00
|
|
|
tcp_wrappers = callPackage ../development/libraries/tcp-wrappers {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
tdb = callPackage ../development/libraries/tdb { };
|
2010-02-10 14:28:18 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
tecla = callPackage ../development/libraries/tecla { };
|
2008-07-15 13:58:30 +04:00
|
|
|
|
2012-03-13 23:06:54 +04:00
|
|
|
telepathy_gabble = callPackage ../development/libraries/telepathy-gabble {
|
|
|
|
inherit (pkgs.gnome) libsoup;
|
|
|
|
};
|
2008-01-28 22:49:44 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
telepathy_glib = callPackage ../development/libraries/telepathy-glib { };
|
2008-01-28 22:49:44 +03:00
|
|
|
|
2012-03-13 23:07:03 +04:00
|
|
|
telepathy_farsight = callPackage ../development/libraries/telepathy-farsight {
|
|
|
|
inherit (pkgs.gst_all) gstPluginsBase gstreamer gst_python;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
telepathy_qt = callPackage ../development/libraries/telepathy-qt { };
|
2008-01-28 22:49:44 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
tk = callPackage ../development/libraries/tk { };
|
2007-12-01 19:20:23 +03:00
|
|
|
|
2010-10-14 15:53:53 +04:00
|
|
|
tnt = callPackage ../development/libraries/tnt { };
|
|
|
|
|
2010-10-31 01:44:29 +04:00
|
|
|
tokyocabinet = callPackage ../development/libraries/tokyo-cabinet { };
|
2011-12-05 02:02:55 +04:00
|
|
|
tokyotyrant = callPackage ../development/libraries/tokyo-tyrant { };
|
2010-10-31 01:44:29 +04:00
|
|
|
|
2011-03-11 01:20:35 +03:00
|
|
|
tremor = callPackage ../development/libraries/tremor { };
|
|
|
|
|
2010-10-14 14:10:45 +04:00
|
|
|
unicap = callPackage ../development/libraries/unicap {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
unixODBC = callPackage ../development/libraries/unixODBC { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2008-06-12 03:03:30 +04:00
|
|
|
unixODBCDrivers = recurseIntoAttrs (import ../development/libraries/unixODBCDrivers {
|
|
|
|
inherit fetchurl stdenv unixODBC glibc libtool openssl zlib;
|
2008-06-13 13:44:43 +04:00
|
|
|
inherit postgresql mysql sqlite;
|
2008-06-12 03:03:30 +04:00
|
|
|
});
|
|
|
|
|
2010-10-14 15:54:06 +04:00
|
|
|
urt = callPackage ../development/libraries/urt { };
|
|
|
|
|
2011-03-28 03:31:31 +04:00
|
|
|
ustr = callPackage ../development/libraries/ustr { };
|
2011-03-27 08:46:05 +04:00
|
|
|
|
2011-01-20 00:17:05 +03:00
|
|
|
ucommon = callPackage ../development/libraries/ucommon { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
vamp = callPackage ../development/libraries/audio/vamp { };
|
2009-09-21 13:58:30 +04:00
|
|
|
|
2012-01-09 14:25:42 +04:00
|
|
|
vcdimager = callPackage ../development/libraries/vcdimager { };
|
|
|
|
|
2012-02-17 17:03:41 +04:00
|
|
|
vigra = callPackage ../development/libraries/vigra {
|
|
|
|
inherit (pkgs.pythonPackages) numpy;
|
|
|
|
};
|
2009-09-21 13:58:30 +04:00
|
|
|
|
2011-02-06 18:27:14 +03:00
|
|
|
vmime = callPackage ../development/libraries/vmime { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
vtk = callPackage ../development/libraries/vtk { };
|
2009-02-08 19:27:57 +03:00
|
|
|
|
2012-03-07 14:16:53 +04:00
|
|
|
vxl = callPackage ../development/libraries/vxl {
|
|
|
|
libpng = libpng12;
|
|
|
|
};
|
2009-01-13 00:12:07 +03:00
|
|
|
|
2011-07-05 17:43:44 +04:00
|
|
|
webkit =
|
2011-07-05 19:14:44 +04:00
|
|
|
builderDefsPackage ../development/libraries/webkit {
|
2011-10-08 20:58:32 +04:00
|
|
|
inherit (gnome) gtkdoc libsoup;
|
2011-07-05 19:14:44 +04:00
|
|
|
inherit (gtkLibs) gtk atk pango glib;
|
|
|
|
inherit freetype fontconfig gettext gperf curl
|
2012-01-27 19:12:59 +04:00
|
|
|
libjpeg libtiff libxml2 libxslt sqlite
|
2011-07-05 17:43:44 +04:00
|
|
|
icu cairo perl intltool automake libtool
|
|
|
|
pkgconfig autoconf bison libproxy enchant
|
2011-07-05 19:14:44 +04:00
|
|
|
python ruby which flex geoclue;
|
|
|
|
inherit (gst_all) gstreamer gstPluginsBase gstFfmpeg
|
2011-07-05 17:43:44 +04:00
|
|
|
gstPluginsGood;
|
2011-07-05 19:14:44 +04:00
|
|
|
inherit (xlibs) libXt renderproto libXrender;
|
2012-01-27 19:12:59 +04:00
|
|
|
libpng = libpng12;
|
2011-07-05 19:14:44 +04:00
|
|
|
};
|
2011-07-08 01:32:55 +04:00
|
|
|
|
2011-07-05 17:43:44 +04:00
|
|
|
webkitSVN =
|
2011-07-05 19:14:44 +04:00
|
|
|
builderDefsPackage ../development/libraries/webkit/svn.nix {
|
2011-10-08 20:58:32 +04:00
|
|
|
inherit (gnome) gtkdoc libsoup;
|
2011-07-05 19:14:44 +04:00
|
|
|
inherit (gtkLibs) gtk atk pango glib;
|
|
|
|
inherit freetype fontconfig gettext gperf curl
|
2012-01-27 19:12:59 +04:00
|
|
|
libjpeg libtiff libxml2 libxslt sqlite
|
2011-07-05 17:43:44 +04:00
|
|
|
icu cairo perl intltool automake libtool
|
|
|
|
pkgconfig autoconf bison libproxy enchant
|
2011-07-05 19:14:44 +04:00
|
|
|
python ruby which flex geoclue;
|
|
|
|
inherit (gst_all) gstreamer gstPluginsBase gstFfmpeg
|
2011-07-05 17:43:44 +04:00
|
|
|
gstPluginsGood;
|
2011-07-05 19:14:44 +04:00
|
|
|
inherit (xlibs) libXt renderproto libXrender;
|
2012-01-27 19:12:59 +04:00
|
|
|
libpng = libpng12;
|
2011-07-05 19:14:44 +04:00
|
|
|
};
|
2008-06-29 11:02:11 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
wvstreams = callPackage ../development/libraries/wvstreams { };
|
2010-04-16 19:56:28 +04:00
|
|
|
|
2009-11-05 16:29:52 +03:00
|
|
|
wxGTK = wxGTK28;
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
wxGTK28 = callPackage ../development/libraries/wxGTK-2.8 {
|
2010-10-06 19:32:25 +04:00
|
|
|
inherit (gtkLibs) gtk;
|
2012-01-13 14:32:02 +04:00
|
|
|
inherit (gst_all) gstreamer gstPluginsBase;
|
|
|
|
inherit (gnome) GConf;
|
2012-03-14 01:56:24 +04:00
|
|
|
withMesa = stdenv.isLinux;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2012-01-13 14:31:52 +04:00
|
|
|
wxGTK290 = callPackage ../development/libraries/wxGTK-2.9/2.9.0.nix {
|
2011-03-24 01:05:14 +03:00
|
|
|
inherit (gtkLibs) gtk;
|
2012-01-13 14:32:02 +04:00
|
|
|
inherit (gst_all) gstreamer gstPluginsBase;
|
|
|
|
inherit (gnome) GConf;
|
2011-03-24 01:05:14 +03:00
|
|
|
};
|
|
|
|
|
2012-01-13 14:31:52 +04:00
|
|
|
wxGTK291 = callPackage ../development/libraries/wxGTK-2.9/2.9.1.nix {
|
2011-03-27 10:44:34 +04:00
|
|
|
inherit (gtkLibs) gtk;
|
2012-01-13 14:32:02 +04:00
|
|
|
inherit (gst_all) gstreamer gstPluginsBase;
|
|
|
|
inherit (gnome) GConf;
|
2011-03-27 10:44:34 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
wtk = callPackage ../development/libraries/wtk { };
|
2009-03-23 23:36:48 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
x264 = callPackage ../development/libraries/x264 { };
|
2008-05-22 04:18:45 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xapian = callPackage ../development/libraries/xapian { };
|
2009-08-21 00:18:58 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xapianBindings = callPackage ../development/libraries/xapian/bindings { # TODO perl php Java, tcl, C#, python
|
2009-08-21 00:18:58 +04:00
|
|
|
};
|
|
|
|
|
2011-04-27 00:57:11 +04:00
|
|
|
xapian10 = callPackage ../development/libraries/xapian/1.0.x.nix { };
|
2009-08-21 00:18:58 +04:00
|
|
|
|
2011-04-27 00:57:11 +04:00
|
|
|
xapianBindings10 = callPackage ../development/libraries/xapian/bindings/1.0.x.nix { # TODO perl php Java, tcl, C#, python
|
2009-08-21 00:18:58 +04:00
|
|
|
};
|
|
|
|
|
2010-12-13 00:48:29 +03:00
|
|
|
Xaw3d = callPackage ../development/libraries/Xaw3d { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2010-09-22 22:04:34 +04:00
|
|
|
xbase = callPackage ../development/libraries/xbase { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xineLib = callPackage ../development/libraries/xine-lib { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xautolock = callPackage ../misc/screensavers/xautolock { };
|
2008-07-07 15:54:25 +04:00
|
|
|
|
2011-03-02 20:18:30 +03:00
|
|
|
xercesc = callPackage ../development/libraries/xercesc {};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
xercesJava = callPackage ../development/libraries/java/xerces {
|
2009-10-01 13:06:59 +04:00
|
|
|
ant = apacheAntGcj; # for bootstrap purposes
|
|
|
|
javac = gcj;
|
|
|
|
jvm = gcj;
|
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
xlibsWrapper = callPackage ../development/libraries/xlibs-wrapper {
|
2007-12-31 01:02:04 +03:00
|
|
|
packages = [
|
|
|
|
freetype fontconfig xlibs.xproto xlibs.libX11 xlibs.libXt
|
|
|
|
xlibs.libXft xlibs.libXext xlibs.libSM xlibs.libICE
|
|
|
|
xlibs.xextproto
|
|
|
|
];
|
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2012-02-23 15:27:47 +04:00
|
|
|
xmlrpc_c = callPackage ../development/libraries/xmlrpc-c { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xvidcore = callPackage ../development/libraries/xvidcore { };
|
2010-05-01 01:47:09 +04:00
|
|
|
|
2011-10-14 18:00:50 +04:00
|
|
|
yajl = callPackage ../development/libraries/yajl { };
|
|
|
|
|
2009-05-12 08:28:30 +04:00
|
|
|
zangband = builderDefsPackage (import ../games/zangband) {
|
2009-05-12 13:45:24 +04:00
|
|
|
inherit ncurses flex bison autoconf automake m4 coreutils;
|
2009-05-12 08:28:30 +04:00
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
zlib = callPackage ../development/libraries/zlib {
|
2008-05-27 11:49:55 +04:00
|
|
|
fetchurl = fetchurlBoot;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2005-03-11 14:08:38 +03:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
zlibStatic = lowPrio (appendToName "static" (import ../development/libraries/zlib {
|
|
|
|
inherit fetchurl stdenv;
|
|
|
|
static = true;
|
|
|
|
}));
|
2004-01-21 12:34:19 +03:00
|
|
|
|
2011-12-14 12:31:14 +04:00
|
|
|
zeromq = callPackage ../development/libraries/zeromq {};
|
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
### DEVELOPMENT / LIBRARIES / JAVA
|
2005-10-12 15:57:24 +04:00
|
|
|
|
2006-07-04 20:58:25 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
atermjava = callPackage ../development/libraries/java/aterm {
|
2007-12-31 01:02:04 +03:00
|
|
|
stdenv = overrideInStdenv stdenv [gnumake380];
|
2005-02-15 19:22:20 +03:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2003-11-06 18:24:19 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
commonsFileUpload = callPackage ../development/libraries/java/jakarta-commons/file-upload { };
|
2009-07-27 14:43:20 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
fastjar = callPackage ../development/tools/java/fastjar { };
|
2007-08-18 13:35:54 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
httpunit = callPackage ../development/libraries/java/httpunit { };
|
2008-02-26 11:48:40 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gwtdragdrop = callPackage ../development/libraries/java/gwt-dragdrop { };
|
2008-02-25 15:45:17 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gwtwidgets = callPackage ../development/libraries/java/gwt-widgets { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
jakartabcel = callPackage ../development/libraries/java/jakarta-bcel {
|
2007-12-31 01:02:04 +03:00
|
|
|
regexp = jakartaregexp;
|
|
|
|
};
|
2006-09-15 19:28:53 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jakartaregexp = callPackage ../development/libraries/java/jakarta-regexp { };
|
2006-12-11 05:35:05 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
javaCup = callPackage ../development/libraries/java/cup { };
|
2004-04-05 18:09:01 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
javasvn = callPackage ../development/libraries/java/javasvn { };
|
2007-03-05 02:37:34 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
jclasslib = callPackage ../development/tools/java/jclasslib {
|
2007-12-31 01:02:04 +03:00
|
|
|
ant = apacheAnt14;
|
|
|
|
};
|
2003-11-06 19:28:57 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jdom = callPackage ../development/libraries/java/jdom { };
|
2007-03-19 02:58:22 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jflex = callPackage ../development/libraries/java/jflex { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
jjtraveler = callPackage ../development/libraries/java/jjtraveler {
|
2007-12-31 01:02:04 +03:00
|
|
|
stdenv = overrideInStdenv stdenv [gnumake380];
|
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
junit = callPackage ../development/libraries/java/junit { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
lucene = callPackage ../development/libraries/java/lucene { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mockobjects = callPackage ../development/libraries/java/mockobjects { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
saxon = callPackage ../development/libraries/java/saxon { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
saxonb = callPackage ../development/libraries/java/saxon/default8.nix { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
sharedobjects = callPackage ../development/libraries/java/shared-objects {
|
2007-12-31 01:02:04 +03:00
|
|
|
stdenv = overrideInStdenv stdenv [gnumake380];
|
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
smack = callPackage ../development/libraries/java/smack { };
|
2008-02-26 12:07:12 +03:00
|
|
|
|
2012-03-09 17:24:16 +04:00
|
|
|
swt = callPackage ../development/libraries/java/swt {
|
|
|
|
inherit (gnome) libsoup;
|
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2010-11-22 17:23:06 +03:00
|
|
|
v8 = callPackage ../development/libraries/v8 { };
|
|
|
|
|
2009-10-01 13:07:17 +04:00
|
|
|
xalanj = xalanJava;
|
2010-08-03 01:40:34 +04:00
|
|
|
xalanJava = callPackage ../development/libraries/java/xalanj {
|
2009-10-01 13:07:17 +04:00
|
|
|
ant = apacheAntGcj; # for bootstrap purposes
|
|
|
|
javac = gcj;
|
|
|
|
jvm = gcj;
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xerces = xercesJava; };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
zziplib = callPackage ../development/libraries/zziplib { };
|
2009-07-31 14:24:02 +04:00
|
|
|
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2011-01-09 18:43:53 +03:00
|
|
|
### DEVELOPMENT / LIBRARIES / JAVASCRIPT
|
|
|
|
|
|
|
|
jquery_ui = callPackage ../development/libraries/javascript/jquery-ui { };
|
2011-02-24 14:25:16 +03:00
|
|
|
|
2011-01-09 18:43:53 +03:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
### DEVELOPMENT / PERL MODULES
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2008-11-24 13:24:51 +03:00
|
|
|
buildPerlPackage = import ../development/perl-modules/generic perl;
|
2008-08-29 13:05:49 +04:00
|
|
|
|
2009-04-20 16:24:13 +04:00
|
|
|
perlPackages = recurseIntoAttrs (import ./perl-packages.nix {
|
2009-04-20 16:08:09 +04:00
|
|
|
inherit pkgs;
|
2009-04-20 16:24:13 +04:00
|
|
|
});
|
2008-08-29 13:05:49 +04:00
|
|
|
|
2012-03-08 14:12:02 +04:00
|
|
|
perl510Packages = recurseIntoAttrs (import ./perl-packages.nix {
|
2012-03-08 16:03:29 +04:00
|
|
|
pkgs = pkgs // {
|
|
|
|
perl = perl510;
|
|
|
|
buildPerlPackage = import ../development/perl-modules/generic perl510;
|
|
|
|
};
|
2012-03-08 14:12:02 +04:00
|
|
|
});
|
|
|
|
|
2009-04-20 16:49:35 +04:00
|
|
|
perlXMLParser = perlPackages.XMLParser;
|
2008-01-22 19:26:57 +03:00
|
|
|
|
2010-03-30 03:36:38 +04:00
|
|
|
ack = perlPackages.ack;
|
2008-07-21 18:43:33 +04:00
|
|
|
|
2010-03-30 03:36:40 +04:00
|
|
|
perlcritic = perlPackages.PerlCritic;
|
2008-07-21 18:43:33 +04:00
|
|
|
|
2010-07-26 17:41:09 +04:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
### DEVELOPMENT / PYTHON MODULES
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2011-03-29 19:02:15 +04:00
|
|
|
buildPythonPackage = pythonPackages.buildPythonPackage;
|
2010-01-08 01:47:30 +03:00
|
|
|
|
2011-03-28 13:48:57 +04:00
|
|
|
pythonPackages = python27Packages;
|
2010-04-21 14:51:15 +04:00
|
|
|
|
2010-01-08 01:47:30 +03:00
|
|
|
python26Packages = recurseIntoAttrs (import ./python-packages.nix {
|
2009-05-25 01:08:39 +04:00
|
|
|
inherit pkgs;
|
2010-01-08 01:47:30 +03:00
|
|
|
python = python26;
|
2009-05-25 01:08:39 +04:00
|
|
|
});
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2010-08-11 19:49:03 +04:00
|
|
|
python27Packages = recurseIntoAttrs (import ./python-packages.nix {
|
|
|
|
inherit pkgs;
|
|
|
|
python = python27;
|
|
|
|
});
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
foursuite = callPackage ../development/python-modules/4suite { };
|
2008-06-19 02:48:34 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
bsddb3 = callPackage ../development/python-modules/bsddb3 { };
|
2008-07-22 17:01:30 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
numeric = callPackage ../development/python-modules/numeric { };
|
2008-08-26 16:50:03 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pil = callPackage ../development/python-modules/pil { };
|
2008-08-26 16:50:03 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
psyco = callPackage ../development/python-modules/psyco { };
|
2008-08-26 16:50:03 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pycairo = callPackage ../development/python-modules/pycairo { };
|
2008-07-31 16:36:47 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pycrypto = callPackage ../development/python-modules/pycrypto { };
|
2008-01-25 15:42:07 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pycups = callPackage ../development/python-modules/pycups { };
|
2008-01-25 15:42:07 +03:00
|
|
|
|
2011-08-23 00:26:11 +04:00
|
|
|
pyexiv2 = callPackage ../development/python-modules/pyexiv2 { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pygame = callPackage ../development/python-modules/pygame { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pygobject = callPackage ../development/python-modules/pygobject { };
|
2008-08-26 16:50:03 +04:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
pygtk = callPackage ../development/python-modules/pygtk { };
|
2008-10-23 18:22:36 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
pyGtkGlade = callPackage ../development/python-modules/pygtk {
|
2009-04-12 23:34:20 +04:00
|
|
|
inherit (gnome) libglade;
|
2008-01-22 22:02:55 +03:00
|
|
|
};
|
|
|
|
|
2009-04-12 23:34:20 +04:00
|
|
|
pyopenssl = builderDefsPackage (import ../development/python-modules/pyopenssl) {
|
|
|
|
inherit python openssl;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rhpl = callPackage ../development/python-modules/rhpl { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
sip = callPackage ../development/python-modules/python-sip { };
|
2008-05-30 22:15:25 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pyqt4 = callPackage ../development/python-modules/pyqt { };
|
2010-02-10 19:09:12 +03:00
|
|
|
|
2011-12-18 00:16:45 +04:00
|
|
|
pysideApiextractor = callPackage ../development/python-modules/pyside/apiextractor.nix { };
|
|
|
|
|
|
|
|
pysideGeneratorrunner = callPackage ../development/python-modules/pyside/generatorrunner.nix { };
|
|
|
|
|
|
|
|
pyside = callPackage ../development/python-modules/pyside { };
|
|
|
|
|
|
|
|
pysideTools = callPackage ../development/python-modules/pyside/tools.nix { };
|
|
|
|
|
|
|
|
pysideShiboken = callPackage ../development/python-modules/pyside/shiboken.nix { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pyx = callPackage ../development/python-modules/pyx { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pyxml = callPackage ../development/python-modules/pyxml { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2011-03-29 19:02:15 +04:00
|
|
|
setuptools = pythonPackages.setuptools;
|
2008-05-30 22:15:25 +04:00
|
|
|
|
2011-05-04 12:41:50 +04:00
|
|
|
wxPython = pythonPackages.wxPython;
|
|
|
|
wxPython28 = pythonPackages.wxPython28;
|
2008-05-30 22:15:25 +04:00
|
|
|
|
2009-05-25 01:27:30 +04:00
|
|
|
twisted = pythonPackages.twisted;
|
2009-02-12 18:59:22 +03:00
|
|
|
|
2010-03-01 16:12:52 +03:00
|
|
|
ZopeInterface = pythonPackages.zopeInterface;
|
2009-02-12 18:59:22 +03:00
|
|
|
|
2011-03-16 12:56:19 +03:00
|
|
|
/*
|
2010-08-03 01:40:34 +04:00
|
|
|
zope = callPackage ../development/python-modules/zope {
|
2008-09-19 18:39:57 +04:00
|
|
|
python = python24;
|
2009-02-12 18:59:22 +03:00
|
|
|
};
|
2011-03-16 12:56:19 +03:00
|
|
|
*/
|
2010-04-21 14:51:15 +04:00
|
|
|
|
2009-02-12 18:59:22 +03:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
### SERVERS
|
2008-05-30 22:15:25 +04:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
rdf4store = callPackage ../servers/http/4store { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
apacheHttpd = callPackage ../servers/http/apache-httpd {
|
2007-12-31 01:02:04 +03:00
|
|
|
sslSupport = true;
|
2009-02-20 13:56:47 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
sabnzbd = callPackage ../servers/sabnzbd { };
|
2009-11-08 22:55:37 +03:00
|
|
|
|
2011-03-31 15:09:20 +04:00
|
|
|
bind = callPackage ../servers/dns/bind {
|
2011-01-07 14:33:04 +03:00
|
|
|
inherit openssl libtool perl;
|
2009-02-12 18:59:22 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dico = callPackage ../servers/dico { };
|
2009-02-12 18:59:22 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dict = callPackage ../servers/dict { };
|
2008-03-06 07:39:05 +03:00
|
|
|
|
|
|
|
dictdDBs = recurseIntoAttrs (import ../servers/dict/dictd-db.nix {
|
|
|
|
inherit builderDefs;
|
|
|
|
});
|
|
|
|
|
2008-03-07 09:11:08 +03:00
|
|
|
dictDBCollector = import ../servers/dict/dictd-db-collector.nix {
|
|
|
|
inherit stdenv lib dict;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dovecot = callPackage ../servers/mail/dovecot { };
|
|
|
|
dovecot_1_1_1 = callPackage ../servers/mail/dovecot/1.1.1.nix { };
|
2011-10-26 00:34:19 +04:00
|
|
|
dovecot_2_0 = callPackage ../servers/mail/dovecot/2.0.nix { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2012-01-26 17:57:57 +04:00
|
|
|
ejabberd = callPackage ../servers/xmpp/ejabberd { };
|
2008-01-23 13:06:07 +03:00
|
|
|
|
2011-12-15 16:24:25 +04:00
|
|
|
couchdb = callPackage ../servers/http/couchdb {
|
|
|
|
spidermonkey = spidermonkey_185;
|
|
|
|
};
|
2010-04-29 12:54:02 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
felix = callPackage ../servers/felix { };
|
2010-04-29 12:54:02 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
felix_remoteshell = callPackage ../servers/felix/remoteshell.nix { };
|
2009-11-05 17:41:05 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
fingerd_bsd = callPackage ../servers/fingerd/bsd-fingerd { };
|
2008-01-28 22:51:14 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
firebird = callPackage ../servers/firebird { };
|
2010-06-03 19:19:56 +04:00
|
|
|
|
2011-06-14 06:41:28 +04:00
|
|
|
freepops = callPackage ../servers/mail/freepops { };
|
|
|
|
|
2011-01-22 01:12:34 +03:00
|
|
|
freeswitch = callPackage ../servers/sip/freeswitch { };
|
|
|
|
|
2010-12-15 05:19:59 +03:00
|
|
|
ghostOne = callPackage ../servers/games/ghost-one {
|
|
|
|
boost = boostFull;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ircdHybrid = callPackage ../servers/irc/ircd-hybrid { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jboss = callPackage ../servers/http/jboss { };
|
2008-01-23 15:25:08 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jboss_mysql_jdbc = callPackage ../servers/http/jboss/jdbc/mysql { };
|
2008-01-29 14:11:26 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jetty = callPackage ../servers/http/jetty { };
|
2007-09-03 16:10:57 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jetty61 = callPackage ../servers/http/jetty/6.1 { };
|
2008-02-26 12:26:17 +03:00
|
|
|
|
2011-03-06 01:05:00 +03:00
|
|
|
joseki = callPackage ../servers/http/joseki {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
lighttpd = callPackage ../servers/http/lighttpd { };
|
2008-09-24 04:42:50 +04:00
|
|
|
|
2011-08-01 16:03:16 +04:00
|
|
|
mediatomb = callPackage ../servers/mediatomb {
|
|
|
|
ffmpeg = ffmpeg_0_6_90;
|
|
|
|
};
|
2011-07-11 04:42:02 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mod_python = callPackage ../servers/http/apache-modules/mod_python { };
|
2007-11-11 19:19:00 +03:00
|
|
|
|
2010-10-21 19:39:48 +04:00
|
|
|
mod_fastcgi = callPackage ../servers/http/apache-modules/mod_fastcgi { };
|
|
|
|
|
2010-10-21 19:39:58 +04:00
|
|
|
mod_wsgi = callPackage ../servers/http/apache-modules/mod_wsgi { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mpd = callPackage ../servers/mpd { };
|
2011-12-05 05:32:25 +04:00
|
|
|
mpd_clientlib = callPackage ../servers/mpd/clientlib.nix { };
|
2010-04-18 23:26:30 +04:00
|
|
|
|
2011-08-16 18:01:38 +04:00
|
|
|
miniHttpd = callPackage ../servers/http/mini-httpd {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
myserver = callPackage ../servers/http/myserver { };
|
2009-08-21 14:20:40 +04:00
|
|
|
|
2011-10-31 22:26:20 +04:00
|
|
|
nginx = callPackage ../servers/http/nginx { };
|
2008-11-30 12:06:53 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
postfix = callPackage ../servers/mail/postfix { };
|
2008-06-13 08:31:31 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
pulseaudio = callPackage ../servers/pulseaudio {
|
2008-12-19 17:56:37 +03:00
|
|
|
gconf = gnome.GConf;
|
2011-07-31 23:44:58 +04:00
|
|
|
# The following are disabled in the default build, because if this
|
|
|
|
# functionality is desired, they are only needed in the PulseAudio
|
|
|
|
# server.
|
|
|
|
bluez = null;
|
|
|
|
avahi = null;
|
2008-12-19 17:56:37 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
tomcat_connectors = callPackage ../servers/http/apache-modules/tomcat-connectors { };
|
2008-01-23 17:40:03 +03:00
|
|
|
|
2011-04-24 01:15:11 +04:00
|
|
|
pies = callPackage ../servers/pies { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
portmap = callPackage ../servers/portmap { };
|
2008-03-16 01:51:46 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
monetdb = callPackage ../servers/sql/monetdb { };
|
2009-07-09 07:50:44 +04:00
|
|
|
|
2012-01-19 00:32:41 +04:00
|
|
|
mongodb = callPackage ../servers/nosql/mongodb { useV8 = (getConfig ["mongodb" "useV8"] false); };
|
|
|
|
|
2008-02-25 06:16:07 +03:00
|
|
|
mysql4 = import ../servers/sql/mysql {
|
2007-12-31 01:02:04 +03:00
|
|
|
inherit fetchurl stdenv ncurses zlib perl;
|
|
|
|
ps = procps; /* !!! Linux only */
|
|
|
|
};
|
2007-11-11 19:22:29 +03:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
mysql5 = import ../servers/sql/mysql5 {
|
2008-02-21 02:02:41 +03:00
|
|
|
inherit fetchurl stdenv ncurses zlib perl openssl;
|
2007-12-31 01:02:04 +03:00
|
|
|
ps = procps; /* !!! Linux only */
|
|
|
|
};
|
2007-11-11 19:17:21 +03:00
|
|
|
|
2009-12-17 21:54:12 +03:00
|
|
|
mysql51 = import ../servers/sql/mysql51 {
|
|
|
|
inherit fetchurl ncurses zlib perl openssl stdenv;
|
|
|
|
ps = procps; /* !!! Linux only */
|
|
|
|
};
|
|
|
|
|
2011-08-04 02:10:06 +04:00
|
|
|
mysql55 = callPackage ../servers/sql/mysql55 { };
|
|
|
|
|
2010-08-12 00:16:09 +04:00
|
|
|
mysql = mysql51;
|
2008-02-25 06:16:07 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mysql_jdbc = callPackage ../servers/sql/mysql/jdbc { };
|
2005-09-07 18:57:30 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
nagios = callPackage ../servers/monitoring/nagios {
|
2007-12-31 01:02:04 +03:00
|
|
|
gdSupport = true;
|
|
|
|
};
|
2007-02-27 02:10:25 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
nagiosPluginsOfficial = callPackage ../servers/monitoring/nagios/plugins/official { };
|
2005-08-14 01:35:49 +04:00
|
|
|
|
2011-11-11 02:29:58 +04:00
|
|
|
oidentd = callPackage ../servers/identd/oidentd { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
openfire = callPackage ../servers/xmpp/openfire { };
|
2012-03-14 10:57:58 +04:00
|
|
|
|
|
|
|
OVMF = callPackage ../applications/virtualization/OVMF { };
|
2008-02-21 19:24:44 +03:00
|
|
|
|
2009-10-14 18:38:16 +04:00
|
|
|
postgresql = postgresql83;
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
postgresql83 = callPackage ../servers/sql/postgresql/8.3.x.nix { };
|
2009-09-04 16:55:03 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
postgresql84 = callPackage ../servers/sql/postgresql/8.4.x.nix { };
|
2006-06-18 02:04:42 +04:00
|
|
|
|
2010-12-14 00:55:34 +03:00
|
|
|
postgresql90 = callPackage ../servers/sql/postgresql/9.0.x.nix { };
|
|
|
|
|
2012-02-22 20:40:10 +04:00
|
|
|
postgresql91 = callPackage ../servers/sql/postgresql/9.1.x.nix { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
postgresql_jdbc = callPackage ../servers/sql/postgresql/jdbc { };
|
2005-01-20 01:51:27 +03:00
|
|
|
|
2009-04-13 03:27:55 +04:00
|
|
|
pyIRCt = builderDefsPackage (import ../servers/xmpp/pyIRCt) {
|
|
|
|
inherit xmpppy pythonIRClib python makeWrapper;
|
|
|
|
};
|
|
|
|
|
|
|
|
pyMAILt = builderDefsPackage (import ../servers/xmpp/pyMAILt) {
|
|
|
|
inherit xmpppy python makeWrapper fetchcvs;
|
|
|
|
};
|
|
|
|
|
2011-03-31 15:09:20 +04:00
|
|
|
rabbitmq_server = callPackage ../servers/amqp/rabbitmq-server { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
radius = callPackage ../servers/radius { };
|
2010-04-26 12:45:23 +04:00
|
|
|
|
2012-02-03 17:12:07 +04:00
|
|
|
redis = callPackage ../servers/nosql/redis { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
redstore = callPackage ../servers/http/redstore { };
|
2010-06-30 02:18:49 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
samba = callPackage ../servers/samba { };
|
2005-11-12 17:52:16 +03:00
|
|
|
|
2011-11-30 02:54:00 +04:00
|
|
|
# A lightweight Samba, useful for non-Linux-based OSes.
|
|
|
|
samba_light = callPackage ../servers/samba {
|
|
|
|
pam = null;
|
|
|
|
fam = null;
|
|
|
|
cups = null;
|
|
|
|
acl = null;
|
|
|
|
openldap = null;
|
|
|
|
};
|
|
|
|
|
2011-11-20 00:13:02 +04:00
|
|
|
shishi = callPackage ../servers/shishi {
|
|
|
|
# GNU Shishi 1.0.0 fails to build with GnuTLS 3.x.
|
|
|
|
gnutls = gnutls2;
|
|
|
|
};
|
2005-11-12 17:52:16 +03:00
|
|
|
|
2011-01-20 00:17:05 +03:00
|
|
|
sipwitch = callPackage ../servers/sip/sipwitch { };
|
|
|
|
|
2008-12-21 19:36:47 +03:00
|
|
|
squids = recurseIntoAttrs( import ../servers/squid/squids.nix {
|
2011-08-30 11:02:01 +04:00
|
|
|
inherit fetchurl stdenv perl lib composableDerivation
|
|
|
|
openldap pam db4 cyrus_sasl kerberos libcap expat libxml2 libtool
|
|
|
|
openssl;
|
2008-12-21 19:36:47 +03:00
|
|
|
});
|
2011-08-30 11:02:01 +04:00
|
|
|
squid = squids.squid31; # has ipv6 support
|
2008-05-15 21:51:41 +04:00
|
|
|
|
2010-10-05 14:39:12 +04:00
|
|
|
tomcat5 = callPackage ../servers/http/tomcat/5.0.nix { };
|
2005-03-09 20:49:19 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
tomcat6 = callPackage ../servers/http/tomcat/6.0.nix { };
|
2008-01-30 12:41:33 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
tomcat_mysql_jdbc = callPackage ../servers/http/tomcat/jdbc/mysql { };
|
2008-08-04 16:04:24 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
axis2 = callPackage ../servers/http/tomcat/axis2 { };
|
2008-02-04 15:24:41 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
virtuoso = callPackage ../servers/sql/virtuoso { };
|
2010-04-03 21:34:14 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
vsftpd = callPackage ../servers/ftp/vsftpd { };
|
2005-02-27 02:45:19 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xinetd = callPackage ../servers/xinetd { };
|
2009-08-20 00:19:17 +04:00
|
|
|
|
2008-10-08 21:02:48 +04:00
|
|
|
xorg = recurseIntoAttrs (import ../servers/x11/xorg/default.nix {
|
2009-07-11 14:32:27 +04:00
|
|
|
inherit fetchurl fetchsvn stdenv pkgconfig freetype fontconfig
|
2010-01-13 15:43:17 +03:00
|
|
|
libxslt expat libdrm libpng zlib perl mesa
|
2011-10-02 23:53:20 +04:00
|
|
|
xkeyboard_config dbus libuuid openssl gperf m4
|
2011-03-29 00:22:30 +04:00
|
|
|
autoconf libtool xmlto asciidoc udev flex bison python;
|
2010-10-15 16:09:10 +04:00
|
|
|
automake = automake110x;
|
2007-12-31 01:02:04 +03:00
|
|
|
});
|
2007-12-01 08:56:58 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xorgReplacements = callPackage ../servers/x11/xorg/replacements.nix { };
|
2008-10-25 11:19:07 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xorgVideoUnichrome = callPackage ../servers/x11/xorg/unichrome/default.nix { };
|
2009-11-06 00:34:31 +03:00
|
|
|
|
2010-02-15 17:20:28 +03:00
|
|
|
zabbix = recurseIntoAttrs (import ../servers/monitoring/zabbix {
|
|
|
|
inherit fetchurl stdenv pkgconfig postgresql curl openssl zlib;
|
|
|
|
});
|
2008-06-04 01:59:35 +04:00
|
|
|
|
2007-11-11 19:15:29 +03:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
### OS-SPECIFIC
|
2007-12-06 00:25:47 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
afuse = callPackage ../os-specific/linux/afuse { };
|
2009-12-21 11:55:27 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
autofs5 = callPackage ../os-specific/linux/autofs/autofs-v5.nix { };
|
2009-04-30 06:37:00 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
_915resolution = callPackage ../os-specific/linux/915resolution { };
|
2007-01-12 00:55:29 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
nfsUtils = callPackage ../os-specific/linux/nfs-utils { };
|
2005-03-08 18:44:23 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
acpi = callPackage ../os-specific/linux/acpi { };
|
2008-02-21 23:13:36 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
acpid = callPackage ../os-specific/linux/acpid { };
|
2009-02-11 02:12:18 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
acpitool = callPackage ../os-specific/linux/acpitool { };
|
2008-02-21 22:57:40 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
alsaLib = callPackage ../os-specific/linux/alsa-lib { };
|
2009-05-18 17:53:01 +04:00
|
|
|
|
2011-07-26 04:05:10 +04:00
|
|
|
alsaPlugins = callPackage ../os-specific/linux/alsa-plugins {
|
|
|
|
jackaudio = null;
|
|
|
|
};
|
2011-08-10 19:51:20 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
alsaPluginWrapper = callPackage ../os-specific/linux/alsa-plugins/wrapper.nix { };
|
2009-09-21 01:54:23 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
alsaUtils = callPackage ../os-specific/linux/alsa-utils { };
|
2008-02-22 06:06:12 +03:00
|
|
|
|
2012-02-06 00:44:19 +04:00
|
|
|
microcode2ucode = callPackage ../os-specific/linux/microcode/converter.nix { };
|
|
|
|
|
2012-02-02 02:09:35 +04:00
|
|
|
microcodeIntel = callPackage ../os-specific/linux/microcode/intel.nix { };
|
|
|
|
|
2012-02-29 17:30:10 +04:00
|
|
|
apparmor = callPackage ../os-specific/linux/apparmor {
|
|
|
|
inherit (perlPackages) LocaleGettext TermReadKey RpcXML;
|
|
|
|
};
|
|
|
|
|
2011-10-25 03:35:53 +04:00
|
|
|
bcm43xx = callPackage ../os-specific/linux/firmware/bcm43xx { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
bluez = callPackage ../os-specific/linux/bluez { };
|
2009-08-06 00:29:36 +04:00
|
|
|
|
2011-12-19 06:13:38 +04:00
|
|
|
beret = callPackage ../games/beret { };
|
|
|
|
|
2010-09-14 14:54:50 +04:00
|
|
|
bridge_utils = callPackage ../os-specific/linux/bridge-utils { };
|
2004-01-21 12:34:19 +03:00
|
|
|
|
2011-03-27 08:45:46 +04:00
|
|
|
checkpolicy = callPackage ../os-specific/linux/checkpolicy { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cifs_utils = callPackage ../os-specific/linux/cifs-utils { };
|
2010-06-03 18:28:48 +04:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
conky = callPackage ../os-specific/linux/conky { };
|
2010-05-27 23:33:58 +04:00
|
|
|
|
2011-12-21 20:24:40 +04:00
|
|
|
cpufrequtils = callPackage ../os-specific/linux/cpufrequtils { };
|
2009-01-13 00:12:07 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cryopid = callPackage ../os-specific/linux/cryopid { };
|
2008-11-14 15:34:18 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cryptsetup = callPackage ../os-specific/linux/cryptsetup { };
|
2009-03-01 14:11:21 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cramfsswap = callPackage ../os-specific/linux/cramfsswap { };
|
2004-01-21 12:34:19 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
darwinArchUtility = callPackage ../os-specific/darwin/arch { };
|
2009-12-04 18:39:49 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
darwinSwVersUtility = callPackage ../os-specific/darwin/sw_vers { };
|
2009-09-22 12:12:11 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
darwinLipoUtility = callPackage ../os-specific/darwin/lipo { };
|
2010-04-29 18:56:44 +04:00
|
|
|
|
2011-03-25 15:55:15 +03:00
|
|
|
darwinInstallNameToolUtility = callPackage ../os-specific/darwin/install_name_tool { };
|
|
|
|
|
2010-01-07 19:14:10 +03:00
|
|
|
devicemapper = lvm2;
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dmidecode = callPackage ../os-specific/linux/dmidecode { };
|
2008-01-08 03:18:20 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dmtcp = callPackage ../os-specific/linux/dmtcp { };
|
2010-02-04 18:41:45 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
dietlibc = callPackage ../os-specific/linux/dietlibc {
|
2007-12-31 01:02:04 +03:00
|
|
|
# Dietlibc 0.30 doesn't compile on PPC with GCC 4.1, bus GCC 3.4 works.
|
2007-11-21 18:32:20 +03:00
|
|
|
stdenv = if stdenv.system == "powerpc-linux" then overrideGCC stdenv gcc34 else stdenv;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2009-11-06 00:08:53 +03:00
|
|
|
directvnc = builderDefsPackage ../os-specific/linux/directvnc {
|
|
|
|
inherit libjpeg pkgconfig zlib directfb;
|
|
|
|
inherit (xlibs) xproto;
|
|
|
|
};
|
|
|
|
|
2009-09-20 12:38:30 +04:00
|
|
|
dmraid = builderDefsPackage ../os-specific/linux/dmraid {
|
|
|
|
inherit devicemapper;
|
|
|
|
};
|
|
|
|
|
2011-11-01 19:21:31 +04:00
|
|
|
drbd = callPackage ../os-specific/linux/drbd { };
|
2011-11-13 02:19:11 +04:00
|
|
|
|
2010-08-25 12:57:10 +04:00
|
|
|
libuuid =
|
|
|
|
if crossSystem != null && crossSystem.config == "i586-pc-gnu"
|
2011-12-12 23:56:17 +04:00
|
|
|
then (utillinux // {
|
|
|
|
hostDrv = lib.overrideDerivation utillinux.hostDrv (args: {
|
2010-08-25 12:57:10 +04:00
|
|
|
# `libblkid' fails to build on GNU/Hurd.
|
|
|
|
configureFlags = args.configureFlags
|
2010-12-13 02:21:29 +03:00
|
|
|
+ " --disable-libblkid --disable-mount --disable-libmount"
|
2012-03-02 01:48:29 +04:00
|
|
|
+ " --disable-fsck --enable-static --disable-partx";
|
2010-08-25 12:57:10 +04:00
|
|
|
doCheck = false;
|
|
|
|
CPPFLAGS = # ugly hack for ugly software!
|
|
|
|
lib.concatStringsSep " "
|
|
|
|
(map (v: "-D${v}=4096")
|
|
|
|
[ "PATH_MAX" "MAXPATHLEN" "MAXHOSTNAMELEN" ]);
|
|
|
|
});
|
|
|
|
})
|
|
|
|
else if stdenv.isLinux
|
2011-12-12 23:56:17 +04:00
|
|
|
then utillinux
|
2010-08-25 12:57:10 +04:00
|
|
|
else null;
|
2009-03-25 13:55:28 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
e3cfsprogs = callPackage ../os-specific/linux/e3cfsprogs { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2011-03-31 16:20:22 +04:00
|
|
|
ebtables = callPackage ../os-specific/linux/ebtables { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
eject = callPackage ../os-specific/linux/eject { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2008-12-08 15:44:42 +03:00
|
|
|
fbterm = builderDefsPackage (import ../os-specific/linux/fbterm) {
|
2009-10-28 02:49:59 +03:00
|
|
|
inherit fontconfig gpm freetype pkgconfig ncurses;
|
2008-12-08 15:44:42 +03:00
|
|
|
};
|
|
|
|
|
2010-11-26 20:56:23 +03:00
|
|
|
fbtermStdenv = callPackage ../os-specific/linux/fbterm/stdenv.nix { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
fuse = callPackage ../os-specific/linux/fuse { };
|
2003-11-05 15:17:48 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
fxload = callPackage ../os-specific/linux/fxload { };
|
2008-02-03 17:43:19 +03:00
|
|
|
|
2010-12-13 00:48:29 +03:00
|
|
|
gpm = callPackage ../servers/gpm { };
|
2008-05-21 17:27:41 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
hal = callPackage ../os-specific/linux/hal { };
|
2007-12-06 00:25:47 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
halevt = callPackage ../os-specific/linux/hal/hal-evt.nix { };
|
2009-09-10 20:57:53 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
hal_info = callPackage ../os-specific/linux/hal/info.nix { };
|
2009-04-29 01:59:09 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
hal_info_synaptics = callPackage ../os-specific/linux/hal/synaptics.nix { };
|
2009-11-09 01:12:55 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
hdparm = callPackage ../os-specific/linux/hdparm { };
|
2008-04-01 18:02:54 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
hibernate = callPackage ../os-specific/linux/hibernate { };
|
2008-06-19 02:48:34 +04:00
|
|
|
|
2011-06-20 03:30:57 +04:00
|
|
|
hostapd = callPackage ../os-specific/linux/hostapd { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
htop = callPackage ../os-specific/linux/htop { };
|
2003-12-04 00:58:16 +03:00
|
|
|
|
2011-11-02 02:10:51 +04:00
|
|
|
# GNU/Hurd core packages.
|
|
|
|
gnu = recurseIntoAttrs (callPackage ../os-specific/gnu {
|
|
|
|
callPackage = newScope pkgs.gnu;
|
|
|
|
inherit platform crossSystem;
|
2010-05-20 01:28:57 +04:00
|
|
|
});
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
hwdata = callPackage ../os-specific/linux/hwdata { };
|
2007-07-17 21:08:38 +04:00
|
|
|
|
2012-02-06 23:09:04 +04:00
|
|
|
i7z = callPackage ../os-specific/linux/i7z { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ifplugd = callPackage ../os-specific/linux/ifplugd { };
|
2006-10-18 18:04:55 +04:00
|
|
|
|
2011-03-28 17:23:52 +04:00
|
|
|
iotop = callPackage ../os-specific/linux/iotop { };
|
2010-11-23 10:46:18 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
iproute = callPackage ../os-specific/linux/iproute { };
|
2003-12-04 00:58:16 +03:00
|
|
|
|
2011-02-02 19:05:18 +03:00
|
|
|
iputils = callPackage ../os-specific/linux/iputils { };
|
2007-10-01 19:14:50 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
iptables = callPackage ../os-specific/linux/iptables { };
|
2003-12-04 00:58:16 +03:00
|
|
|
|
2010-10-14 16:12:27 +04:00
|
|
|
ipw2100fw = callPackage ../os-specific/linux/firmware/ipw2100 { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ipw2200fw = callPackage ../os-specific/linux/firmware/ipw2200 { };
|
2003-12-04 00:58:16 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
iwlwifi1000ucode = callPackage ../os-specific/linux/firmware/iwlwifi-1000-ucode { };
|
2009-12-26 19:22:51 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
iwlwifi3945ucode = callPackage ../os-specific/linux/firmware/iwlwifi-3945-ucode { };
|
2008-01-13 01:38:37 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
iwlwifi4965ucodeV1 = callPackage ../os-specific/linux/firmware/iwlwifi-4965-ucode { };
|
2008-11-26 16:15:38 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
iwlwifi4965ucodeV2 = callPackage ../os-specific/linux/firmware/iwlwifi-4965-ucode/version-2.nix { };
|
2008-02-18 19:15:51 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
iwlwifi5000ucode = callPackage ../os-specific/linux/firmware/iwlwifi-5000-ucode { };
|
2009-04-29 18:50:59 +04:00
|
|
|
|
2012-01-03 18:14:58 +04:00
|
|
|
iwlwifi5150ucode = callPackage ../os-specific/linux/firmware/iwlwifi-5150-ucode { };
|
|
|
|
|
2011-02-10 20:30:20 +03:00
|
|
|
iwlwifi6000ucode = callPackage ../os-specific/linux/firmware/iwlwifi-6000-ucode { };
|
|
|
|
|
2011-09-05 12:33:03 +04:00
|
|
|
iwlwifi6000g2aucode = callPackage ../os-specific/linux/firmware/iwlwifi-6000g2a-ucode { };
|
|
|
|
|
|
|
|
iwlwifi6000g2bucode = callPackage ../os-specific/linux/firmware/iwlwifi-6000g2b-ucode { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
kbd = callPackage ../os-specific/linux/kbd { };
|
2007-08-09 21:33:18 +04:00
|
|
|
|
2011-04-06 18:21:48 +04:00
|
|
|
libaio = callPackage ../os-specific/linux/libaio { };
|
|
|
|
|
2011-07-23 05:29:51 +04:00
|
|
|
libatasmart = callPackage ../os-specific/linux/libatasmart { };
|
2011-08-10 19:51:20 +04:00
|
|
|
|
2011-11-24 17:48:16 +04:00
|
|
|
libcgroup = callPackage ../os-specific/linux/libcgroup { };
|
2010-07-09 17:15:51 +04:00
|
|
|
|
2010-12-13 00:48:29 +03:00
|
|
|
libnl = callPackage ../os-specific/linux/libnl { };
|
2010-12-06 15:04:36 +03:00
|
|
|
|
2011-06-08 01:50:42 +04:00
|
|
|
libnl2 = callPackage ../os-specific/linux/libnl/v2.nix { };
|
|
|
|
|
2011-01-03 20:02:47 +03:00
|
|
|
libnl1 = callPackage ../os-specific/linux/libnl/v1.nix { };
|
|
|
|
|
2011-12-12 22:51:11 +04:00
|
|
|
linuxHeaders = callPackage ../os-specific/linux/kernel-headers { };
|
2006-06-29 16:41:25 +04:00
|
|
|
|
2010-03-10 23:44:48 +03:00
|
|
|
linuxHeaders26Cross = forceBuildDrv (import ../os-specific/linux/kernel-headers/2.6.32.nix {
|
2010-03-07 02:36:55 +03:00
|
|
|
inherit stdenv fetchurl perl;
|
2010-03-07 03:05:51 +03:00
|
|
|
cross = assert crossSystem != null; crossSystem;
|
Big fixes in the cross build:
- Before this changes, cflags and ldflags for the native and the cross compiler
got mixed. Not all the gcc-wrapper/gcc-cross-wrapper variables are
independant now, but enough, I think.
- Fixed the generic stdenv expression, which did a big mess on buildInputs and
buildNativeInputs. Now it distinguishes when there is a stdenvCross or not.
Maybe we should have a single stdenv and forget about the stdenvCross
adapter - this could end in a stdenv a bit complex, but simpler than the
generic stdenv + adapter.
- Added basic support in pkgconfig for cross-builds: a single PKG_CONFIG_PATH
now works for both the cross and the native compilers, but I think this
should work well for most cases I can think of.
- I tried to fix the guile expression to cross-biuld; guile is built, but not
its manual, so the derivation still fails. Guile requires patching to
cross-build, as far as I understnad.
- Made the glibcCross build to be done through the usage of a
gcc-cross-wrapper over the gcc-cross-stage-static, instead of using it
directly.
- Trying to make physfs (a neverball dependency) cross build.
- Updated the gcc expression to support building a cross compiler without getting
derivation variables mixed with those of the stdenvCross.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18534
2009-11-22 22:51:45 +03:00
|
|
|
});
|
My first attempt at getting cross compilers in nixpkgs.
My idea is to provide special stdenv expressions that will contain in the path
additional cross compilers. As most expressions for programs accept a stdenv parameter,
we could substitute this parameter with the special stdenv, which will have a
generic builder that attempts the usual "--target=..." and can additionally
have an env variable like "cross" with the target architecture set.
So, finally we could have additional expressions like this:
bashRealArm = makeOverridable (import ../shells/bash) {
inherit fetchurl bison;
stdenv = stdenvCross "armv5tel-unknown-linux-gnueabi";
};
Meanwhile it does not work - I still cannot get the cross-gcc to build.
I think it does not fill the previous expressions with a lot of noise, so I
think it may be a good path to follow.
I only touched some files of the current stdenv: gcc-4.3, kernel headers
2.6.28, glibc 2.9, ...
I tried to use the gcc-cross-wrapper, that may be very outdated. Maybe I will
update it, or update the gcc-wrapper expression to make it fit the cross tools,
but meanwhile I even cannot build gcc, so I have not tested the wrapper.
This new idea on cross compiling is not similar to that of the
nixpkgs/branches/cross-compilation, which mostly added bare new expressions for
anything to be cross compiled, if I understood it correctly.
I cared not to break anything of the usual stdenv in all this work.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18343
2009-11-14 11:11:30 +03:00
|
|
|
|
2010-03-10 23:44:48 +03:00
|
|
|
linuxHeaders24Cross = forceBuildDrv (import ../os-specific/linux/kernel-headers/2.4.nix {
|
2010-03-07 02:36:55 +03:00
|
|
|
inherit stdenv fetchurl perl;
|
2010-03-07 03:05:51 +03:00
|
|
|
cross = assert crossSystem != null; crossSystem;
|
Big fixes in the cross build:
- Before this changes, cflags and ldflags for the native and the cross compiler
got mixed. Not all the gcc-wrapper/gcc-cross-wrapper variables are
independant now, but enough, I think.
- Fixed the generic stdenv expression, which did a big mess on buildInputs and
buildNativeInputs. Now it distinguishes when there is a stdenvCross or not.
Maybe we should have a single stdenv and forget about the stdenvCross
adapter - this could end in a stdenv a bit complex, but simpler than the
generic stdenv + adapter.
- Added basic support in pkgconfig for cross-builds: a single PKG_CONFIG_PATH
now works for both the cross and the native compilers, but I think this
should work well for most cases I can think of.
- I tried to fix the guile expression to cross-biuld; guile is built, but not
its manual, so the derivation still fails. Guile requires patching to
cross-build, as far as I understnad.
- Made the glibcCross build to be done through the usage of a
gcc-cross-wrapper over the gcc-cross-stage-static, instead of using it
directly.
- Trying to make physfs (a neverball dependency) cross build.
- Updated the gcc expression to support building a cross compiler without getting
derivation variables mixed with those of the stdenvCross.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18534
2009-11-22 22:51:45 +03:00
|
|
|
});
|
My first attempt at getting cross compilers in nixpkgs.
My idea is to provide special stdenv expressions that will contain in the path
additional cross compilers. As most expressions for programs accept a stdenv parameter,
we could substitute this parameter with the special stdenv, which will have a
generic builder that attempts the usual "--target=..." and can additionally
have an env variable like "cross" with the target architecture set.
So, finally we could have additional expressions like this:
bashRealArm = makeOverridable (import ../shells/bash) {
inherit fetchurl bison;
stdenv = stdenvCross "armv5tel-unknown-linux-gnueabi";
};
Meanwhile it does not work - I still cannot get the cross-gcc to build.
I think it does not fill the previous expressions with a lot of noise, so I
think it may be a good path to follow.
I only touched some files of the current stdenv: gcc-4.3, kernel headers
2.6.28, glibc 2.9, ...
I tried to use the gcc-cross-wrapper, that may be very outdated. Maybe I will
update it, or update the gcc-wrapper expression to make it fit the cross tools,
but meanwhile I even cannot build gcc, so I have not tested the wrapper.
This new idea on cross compiling is not similar to that of the
nixpkgs/branches/cross-compilation, which mostly added bare new expressions for
anything to be cross compiled, if I understood it correctly.
I cared not to break anything of the usual stdenv in all this work.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18343
2009-11-14 11:11:30 +03:00
|
|
|
|
2010-03-10 23:44:48 +03:00
|
|
|
# We can choose:
|
|
|
|
linuxHeadersCrossChooser = ver : if (ver == "2.4") then linuxHeaders24Cross
|
|
|
|
else if (ver == "2.6") then linuxHeaders26Cross
|
|
|
|
else throw "Unknown linux kernel version";
|
|
|
|
|
|
|
|
linuxHeadersCross = assert crossSystem != null;
|
|
|
|
linuxHeadersCrossChooser crossSystem.platform.kernelMajor;
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
linuxHeaders_2_6_28 = callPackage ../os-specific/linux/kernel-headers/2.6.28.nix { };
|
2009-01-13 15:40:58 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
kernelPatches = callPackage ../os-specific/linux/kernel/patches.nix { };
|
2009-01-15 18:54:24 +03:00
|
|
|
|
2011-07-11 18:00:26 +04:00
|
|
|
linux_2_6_15 = makeOverridable (import ../os-specific/linux/kernel/linux-2.6.15.nix) {
|
|
|
|
inherit fetchurl perl mktemp module_init_tools;
|
2012-02-18 03:47:00 +04:00
|
|
|
stdenv = overrideInStdenv stdenv [ gcc34 gnumake381 ];
|
2011-07-11 18:00:26 +04:00
|
|
|
kernelPatches =
|
|
|
|
[ kernelPatches.cifs_timeout_2_6_15
|
|
|
|
];
|
|
|
|
};
|
|
|
|
|
2009-12-21 17:12:00 +03:00
|
|
|
linux_2_6_27 = makeOverridable (import ../os-specific/linux/kernel/linux-2.6.27.nix) {
|
2011-01-27 17:11:47 +03:00
|
|
|
inherit fetchurl perl mktemp module_init_tools;
|
2012-02-18 03:47:00 +04:00
|
|
|
stdenv = overrideGCC (overrideInStdenv stdenv [ gnumake381 ]) gcc45;
|
2009-12-14 18:28:55 +03:00
|
|
|
kernelPatches =
|
|
|
|
[ kernelPatches.fbcondecor_2_6_27
|
|
|
|
kernelPatches.sec_perm_2_6_24
|
2011-08-29 11:46:38 +04:00
|
|
|
kernelPatches.cifs_timeout_2_6_25
|
2009-12-14 18:28:55 +03:00
|
|
|
];
|
2009-08-28 10:29:21 +04:00
|
|
|
};
|
2008-10-29 15:34:54 +03:00
|
|
|
|
2010-01-14 17:49:31 +03:00
|
|
|
linux_2_6_32 = makeOverridable (import ../os-specific/linux/kernel/linux-2.6.32.nix) {
|
Simplified much more the expressions for cross building and multiplatform.
I introduce the new nixpkgs parameter "platform", defaulting to "pc",
which was before defined as an attribute of nixpkgs.
I made the crossSystem nixpkgs attribute set parameter contain its own 'platform'.
This allows cross-building a kernel for a given crossSystem.platform in a non-PC
platform.
The actual native platform can be taken from stdenv.platform, and this way we also
avoid the constant passing of 'platform' to packages for platform-dependant builds
(kernel, initrd, ...).
I will update nixos accordingly to these changes, for non-PC platforms to work.
I think we are gaining on flexibility and clearness. I could cross build succesfully
an ultrasparc kernel and a mipsel kernel on PC. But since this change, I should be able
to do this also in non-PC.
Before this change, there was no possibility of distinguishing the "target platform" or
the "native build platform" when cross building, being the single "platform" attribute
always interpreted as target platform.
The platform is a quite relevant attribute set, as it determines the linuxHeaders used
(in the case, by now the only one supported, of linux targets).
The platform attributes are quite linux centric still. Let's hope for more generality to come.
svn path=/nixpkgs/trunk/; revision=20273
2010-02-27 20:35:47 +03:00
|
|
|
inherit fetchurl stdenv perl mktemp module_init_tools ubootChooser;
|
2009-12-14 18:28:55 +03:00
|
|
|
kernelPatches =
|
|
|
|
[ kernelPatches.fbcondecor_2_6_31
|
|
|
|
kernelPatches.sec_perm_2_6_24
|
2010-05-28 11:09:15 +04:00
|
|
|
kernelPatches.aufs2_2_6_32
|
2011-07-11 17:59:51 +04:00
|
|
|
kernelPatches.cifs_timeout_2_6_29
|
2010-07-19 01:10:46 +04:00
|
|
|
kernelPatches.no_xsave
|
2010-07-25 16:15:59 +04:00
|
|
|
kernelPatches.dell_rfkill
|
2009-12-14 18:28:55 +03:00
|
|
|
];
|
2009-09-11 17:16:18 +04:00
|
|
|
};
|
|
|
|
|
2010-09-10 20:27:39 +04:00
|
|
|
linux_2_6_32_xen = makeOverridable (import ../os-specific/linux/kernel/linux-2.6.32-xen.nix) {
|
|
|
|
inherit fetchurl stdenv perl mktemp module_init_tools ubootChooser;
|
|
|
|
kernelPatches =
|
|
|
|
[ kernelPatches.fbcondecor_2_6_31
|
|
|
|
kernelPatches.sec_perm_2_6_24
|
|
|
|
kernelPatches.aufs2_2_6_32
|
|
|
|
kernelPatches.cifs_timeout
|
|
|
|
kernelPatches.no_xsave
|
|
|
|
kernelPatches.dell_rfkill
|
|
|
|
];
|
|
|
|
};
|
|
|
|
|
2010-05-05 23:48:46 +04:00
|
|
|
linux_2_6_32_systemtap = makeOverridable (import ../os-specific/linux/kernel/linux-2.6.32.nix) {
|
|
|
|
inherit fetchurl stdenv perl mktemp module_init_tools ubootChooser;
|
2010-09-10 18:06:56 +04:00
|
|
|
extraConfig =
|
|
|
|
''
|
|
|
|
DEBUG_KERNEL y
|
|
|
|
KPROBES y # kernel probes (needs `utrace' for process probes)
|
|
|
|
DEBUG_INFO y
|
|
|
|
RELAY y
|
|
|
|
DEBUG_FS y
|
|
|
|
'';
|
2010-05-05 23:48:52 +04:00
|
|
|
dontStrip = true;
|
2010-05-05 23:48:46 +04:00
|
|
|
kernelPatches =
|
|
|
|
[ kernelPatches.fbcondecor_2_6_31
|
|
|
|
kernelPatches.sec_perm_2_6_24
|
2011-08-20 11:55:53 +04:00
|
|
|
kernelPatches.aufs2_2_6_32
|
2010-05-05 23:48:46 +04:00
|
|
|
kernelPatches.tracehook_2_6_32
|
|
|
|
kernelPatches.utrace_2_6_32
|
|
|
|
];
|
|
|
|
};
|
|
|
|
|
2010-08-12 20:33:19 +04:00
|
|
|
linux_2_6_35 = makeOverridable (import ../os-specific/linux/kernel/linux-2.6.35.nix) {
|
|
|
|
inherit fetchurl stdenv perl mktemp module_init_tools ubootChooser;
|
|
|
|
kernelPatches =
|
2011-09-02 17:41:38 +04:00
|
|
|
[ kernelPatches.fbcondecor_2_6_35
|
2010-08-12 20:33:19 +04:00
|
|
|
kernelPatches.sec_perm_2_6_24
|
2010-08-29 14:38:39 +04:00
|
|
|
kernelPatches.aufs2_2_6_35
|
2011-08-29 11:46:38 +04:00
|
|
|
kernelPatches.cifs_timeout_2_6_35
|
2010-10-08 02:10:28 +04:00
|
|
|
] ++ lib.optional (platform.kernelArch == "arm")
|
|
|
|
kernelPatches.sheevaplug_modules_2_6_35;
|
2010-08-12 20:33:19 +04:00
|
|
|
};
|
|
|
|
|
2010-08-04 15:07:13 +04:00
|
|
|
linux_nanonote_jz_2_6_34 = makeOverridable
|
|
|
|
(import ../os-specific/linux/kernel/linux-nanonote-jz-2.6.34.nix) {
|
2010-08-08 22:46:57 +04:00
|
|
|
inherit fetchurl fetchsvn stdenv perl mktemp module_init_tools ubootChooser;
|
2011-08-20 11:55:53 +04:00
|
|
|
kernelPatches =
|
|
|
|
[ kernelPatches.aufs2_2_6_34
|
|
|
|
];
|
2010-08-04 15:07:13 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
linux_nanonote_jz_2_6_35 = makeOverridable
|
|
|
|
(import ../os-specific/linux/kernel/linux-nanonote-jz-2.6.35.nix) {
|
2010-08-08 22:46:57 +04:00
|
|
|
inherit fetchurl fetchsvn stdenv perl mktemp module_init_tools ubootChooser;
|
2011-08-20 11:55:53 +04:00
|
|
|
kernelPatches =
|
|
|
|
[ kernelPatches.aufs2_2_6_35
|
|
|
|
];
|
2010-08-04 15:07:13 +04:00
|
|
|
};
|
|
|
|
|
2010-12-06 18:30:19 +03:00
|
|
|
linux_nanonote_jz_2_6_36 = makeOverridable
|
|
|
|
(import ../os-specific/linux/kernel/linux-nanonote-jz-2.6.36.nix) {
|
|
|
|
inherit fetchurl fetchsvn stdenv perl mktemp module_init_tools ubootChooser;
|
|
|
|
kernelPatches =
|
|
|
|
[ #kernelPatches.fbcondecor_2_6_35
|
|
|
|
kernelPatches.sec_perm_2_6_24
|
2011-08-20 10:39:29 +04:00
|
|
|
kernelPatches.aufs2_2_6_36
|
2010-12-06 18:30:19 +03:00
|
|
|
kernelPatches.mips_restart_2_6_36
|
2011-08-29 11:46:38 +04:00
|
|
|
kernelPatches.cifs_timeout_2_6_35
|
2010-12-06 18:30:19 +03:00
|
|
|
];
|
|
|
|
};
|
|
|
|
|
2010-08-14 21:13:42 +04:00
|
|
|
linux_2_6_35_oldI686 = linux_2_6_35.override {
|
2012-02-18 03:47:00 +04:00
|
|
|
extraConfig = ''
|
|
|
|
HIGHMEM64G? n
|
|
|
|
XEN? n
|
|
|
|
'';
|
|
|
|
extraMeta = {
|
|
|
|
platforms = ["i686-linux"];
|
|
|
|
maintainers = [lib.maintainers.raskin];
|
|
|
|
};
|
2011-01-11 16:42:59 +03:00
|
|
|
};
|
|
|
|
|
2011-03-18 15:23:36 +03:00
|
|
|
linux_2_6_38 = makeOverridable (import ../os-specific/linux/kernel/linux-2.6.38.nix) {
|
|
|
|
inherit fetchurl stdenv perl mktemp module_init_tools ubootChooser;
|
|
|
|
kernelPatches =
|
2011-04-18 19:13:04 +04:00
|
|
|
[ kernelPatches.fbcondecor_2_6_38
|
2011-03-18 15:23:36 +03:00
|
|
|
kernelPatches.sec_perm_2_6_24
|
2011-04-12 22:36:33 +04:00
|
|
|
kernelPatches.aufs2_1_2_6_38
|
2011-08-29 11:46:38 +04:00
|
|
|
kernelPatches.cifs_timeout_2_6_38
|
2011-03-18 15:23:36 +03:00
|
|
|
#kernelPatches.mips_restart_2_6_36
|
2011-05-19 15:17:34 +04:00
|
|
|
];
|
|
|
|
};
|
|
|
|
|
2011-07-15 00:08:51 +04:00
|
|
|
linux_2_6_38_ati = linux_2_6_38.override { extraConfig="DRM_RADEON_KMS y"; };
|
|
|
|
|
2011-05-19 15:17:34 +04:00
|
|
|
linux_2_6_39 = makeOverridable (import ../os-specific/linux/kernel/linux-2.6.39.nix) {
|
|
|
|
inherit fetchurl stdenv perl mktemp module_init_tools ubootChooser;
|
|
|
|
kernelPatches =
|
|
|
|
[ #kernelPatches.fbcondecor_2_6_38
|
|
|
|
kernelPatches.sec_perm_2_6_24
|
2011-08-20 10:39:29 +04:00
|
|
|
kernelPatches.aufs2_1_2_6_39
|
2011-05-19 15:17:34 +04:00
|
|
|
#kernelPatches.mips_restart_2_6_36
|
2011-03-18 15:23:36 +03:00
|
|
|
];
|
|
|
|
};
|
|
|
|
|
2011-07-24 07:05:00 +04:00
|
|
|
linux_3_0 = makeOverridable (import ../os-specific/linux/kernel/linux-3.0.nix) {
|
|
|
|
inherit fetchurl stdenv perl mktemp module_init_tools ubootChooser;
|
|
|
|
kernelPatches =
|
|
|
|
[ #kernelPatches.fbcondecor_2_6_38
|
|
|
|
kernelPatches.sec_perm_2_6_24
|
2011-09-29 01:09:54 +04:00
|
|
|
kernelPatches.aufs3_0
|
2011-09-28 18:18:26 +04:00
|
|
|
#kernelPatches.aufs2_1_3_0
|
2011-07-24 07:05:00 +04:00
|
|
|
#kernelPatches.mips_restart_2_6_36
|
|
|
|
];
|
|
|
|
};
|
|
|
|
|
2011-08-08 16:48:05 +04:00
|
|
|
linux_3_1 = makeOverridable (import ../os-specific/linux/kernel/linux-3.1.nix) {
|
|
|
|
inherit fetchurl stdenv perl mktemp module_init_tools ubootChooser;
|
|
|
|
kernelPatches =
|
|
|
|
[ #kernelPatches.fbcondecor_2_6_38
|
|
|
|
kernelPatches.sec_perm_2_6_24
|
2011-11-08 20:00:19 +04:00
|
|
|
kernelPatches.aufs3_1
|
2011-08-08 16:48:05 +04:00
|
|
|
#kernelPatches.mips_restart_2_6_36
|
2010-10-21 16:28:14 +04:00
|
|
|
];
|
|
|
|
};
|
|
|
|
|
2011-11-08 20:58:20 +04:00
|
|
|
linux_3_2 = makeOverridable (import ../os-specific/linux/kernel/linux-3.2.nix) {
|
|
|
|
inherit fetchurl stdenv perl mktemp module_init_tools ubootChooser;
|
|
|
|
kernelPatches =
|
|
|
|
[ #kernelPatches.fbcondecor_2_6_38
|
|
|
|
kernelPatches.sec_perm_2_6_24
|
2012-02-23 00:29:18 +04:00
|
|
|
kernelPatches.aufs3_2
|
2011-11-08 20:58:20 +04:00
|
|
|
#kernelPatches.mips_restart_2_6_36
|
|
|
|
];
|
|
|
|
};
|
2012-01-04 02:25:38 +04:00
|
|
|
|
2012-03-12 06:19:05 +04:00
|
|
|
linux_3_3 = makeOverridable (import ../os-specific/linux/kernel/linux-3.3.nix) {
|
|
|
|
inherit fetchurl stdenv perl mktemp module_init_tools ubootChooser;
|
|
|
|
kernelPatches =
|
|
|
|
[ #kernelPatches.fbcondecor_2_6_38
|
|
|
|
kernelPatches.sec_perm_2_6_24
|
|
|
|
kernelPatches.aufs3_3
|
|
|
|
#kernelPatches.mips_restart_2_6_36
|
|
|
|
];
|
|
|
|
};
|
|
|
|
|
2009-12-21 17:12:00 +03:00
|
|
|
/* Linux kernel modules are inherently tied to a specific kernel. So
|
2008-05-22 16:01:24 +04:00
|
|
|
rather than provide specific instances of those packages for a
|
|
|
|
specific kernel, we have a function that builds those packages
|
|
|
|
for a specific kernel. This function can then be called for
|
|
|
|
whatever kernel you're using. */
|
2008-06-19 02:48:34 +04:00
|
|
|
|
2010-08-02 17:57:57 +04:00
|
|
|
linuxPackagesFor = kernel: self: let callPackage = newScope self; in rec {
|
2008-05-22 16:01:24 +04:00
|
|
|
|
|
|
|
inherit kernel;
|
|
|
|
|
2010-11-12 01:00:57 +03:00
|
|
|
acpi_call = callPackage ../os-specific/linux/acpi-call {};
|
|
|
|
|
2012-01-26 05:02:22 +04:00
|
|
|
bbswitch = callPackage ../os-specific/linux/bbswitch {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ati_drivers_x11 = callPackage ../os-specific/linux/ati-drivers { };
|
2010-05-18 23:36:55 +04:00
|
|
|
|
2011-11-08 19:05:54 +04:00
|
|
|
aufs =
|
|
|
|
if kernel.features ? aufs2 then
|
2011-11-08 19:15:07 +04:00
|
|
|
callPackage ../os-specific/linux/aufs/2.nix { }
|
2011-11-08 19:05:54 +04:00
|
|
|
else if kernel.features ? aufs2_1 then
|
2011-11-08 19:15:07 +04:00
|
|
|
callPackage ../os-specific/linux/aufs/2.1.nix { }
|
2011-11-08 19:05:54 +04:00
|
|
|
else if kernel.features ? aufs3 then
|
2011-11-08 19:15:07 +04:00
|
|
|
callPackage ../os-specific/linux/aufs/3.nix { }
|
2011-09-29 03:38:39 +04:00
|
|
|
else null;
|
|
|
|
|
2011-11-13 02:19:11 +04:00
|
|
|
aufs_util =
|
2011-11-08 19:05:54 +04:00
|
|
|
if kernel.features ? aufs2 then
|
2011-11-08 19:15:07 +04:00
|
|
|
callPackage ../os-specific/linux/aufs-util/2.nix { }
|
2011-11-08 19:05:54 +04:00
|
|
|
else if kernel.features ? aufs2_1 then
|
2011-11-08 19:15:07 +04:00
|
|
|
callPackage ../os-specific/linux/aufs-util/2.1.nix { }
|
2011-11-08 19:05:54 +04:00
|
|
|
else if kernel.features ? aufs3 then
|
2011-11-08 19:15:07 +04:00
|
|
|
callPackage ../os-specific/linux/aufs-util/3.nix { }
|
2011-09-29 01:59:07 +04:00
|
|
|
else null;
|
2010-08-03 01:40:34 +04:00
|
|
|
|
2010-08-17 20:53:34 +04:00
|
|
|
blcr = callPackage ../os-specific/linux/blcr {
|
|
|
|
#libtool = libtool_1_5; # libtool 2 causes a fork bomb
|
2010-04-15 16:08:08 +04:00
|
|
|
};
|
|
|
|
|
2011-09-15 19:18:45 +04:00
|
|
|
e1000e = callPackage ../os-specific/linux/e1000e {};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
exmap = callPackage ../os-specific/linux/exmap {
|
2008-09-13 00:00:00 +04:00
|
|
|
inherit (gtkLibs) gtkmm;
|
|
|
|
};
|
|
|
|
|
2012-02-06 23:08:52 +04:00
|
|
|
frandom = callPackage ../os-specific/linux/frandom { };
|
|
|
|
|
2010-08-30 13:15:27 +04:00
|
|
|
iscsitarget = callPackage ../os-specific/linux/iscsitarget { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
iwlwifi = callPackage ../os-specific/linux/iwlwifi { };
|
2008-05-22 16:01:24 +04:00
|
|
|
|
2008-11-26 16:15:38 +03:00
|
|
|
iwlwifi4965ucode =
|
|
|
|
(if (builtins.compareVersions kernel.version "2.6.27" == 0)
|
|
|
|
|| (builtins.compareVersions kernel.version "2.6.27" == 1)
|
|
|
|
then iwlwifi4965ucodeV2
|
|
|
|
else iwlwifi4965ucodeV1);
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
atheros = callPackage ../os-specific/linux/atheros/0.9.4.nix { };
|
2008-05-22 23:29:23 +04:00
|
|
|
|
2010-12-09 22:05:19 +03:00
|
|
|
broadcom_sta = callPackage ../os-specific/linux/broadcom-sta/default.nix { };
|
|
|
|
|
2011-09-30 19:34:37 +04:00
|
|
|
kernelHeaders = callPackage ../os-specific/linux/kernel-headers { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
nvidia_x11 = callPackage ../os-specific/linux/nvidia-x11 { };
|
2008-05-22 16:01:24 +04:00
|
|
|
|
2010-08-25 01:56:47 +04:00
|
|
|
nvidia_x11_legacy96 = callPackage ../os-specific/linux/nvidia-x11/legacy96.nix { };
|
|
|
|
nvidia_x11_legacy173 = callPackage ../os-specific/linux/nvidia-x11/legacy173.nix { };
|
2009-09-20 02:09:08 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
openafsClient = callPackage ../servers/openafs-client { };
|
2010-02-01 19:27:35 +03:00
|
|
|
|
2010-08-30 13:40:44 +04:00
|
|
|
openiscsi = callPackage ../os-specific/linux/open-iscsi { };
|
2010-02-01 19:27:35 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
wis_go7007 = callPackage ../os-specific/linux/wis-go7007 { };
|
2008-05-22 16:01:24 +04:00
|
|
|
|
2012-02-17 18:32:28 +04:00
|
|
|
kqemu = callPackage ../os-specific/linux/kqemu { };
|
2008-05-22 23:29:23 +04:00
|
|
|
|
2011-10-25 12:59:39 +04:00
|
|
|
klibc = callPackage ../os-specific/linux/klibc {
|
|
|
|
linuxHeaders = glibc.kernelHeaders;
|
|
|
|
};
|
|
|
|
|
2008-06-19 02:48:34 +04:00
|
|
|
splashutils =
|
2010-01-27 17:35:38 +03:00
|
|
|
if kernel.features ? fbConDecor then pkgs.splashutils else null;
|
2008-06-10 20:09:53 +04:00
|
|
|
|
2008-06-15 15:39:54 +04:00
|
|
|
/* compiles but has to be integrated into the kernel somehow
|
|
|
|
Let's have it uncommented and finish it..
|
|
|
|
*/
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ndiswrapper = callPackage ../os-specific/linux/ndiswrapper { };
|
2008-06-15 15:39:54 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
ov511 = callPackage ../os-specific/linux/ov511 {
|
2008-05-22 16:01:24 +04:00
|
|
|
stdenv = overrideGCC stdenv gcc34;
|
|
|
|
};
|
|
|
|
|
2012-01-06 01:24:51 +04:00
|
|
|
perf = callPackage ../os-specific/linux/kernel/perf.nix { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
sysprof = callPackage ../development/tools/profiling/sysprof {
|
2008-09-05 11:26:37 +04:00
|
|
|
inherit (gnome) gtk glib pango libglade;
|
|
|
|
};
|
2009-01-25 23:09:17 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
systemtap = callPackage ../development/tools/profiling/systemtap {
|
2010-05-04 17:32:09 +04:00
|
|
|
linux = kernel;
|
|
|
|
inherit (gnome) gtkmm libglademm;
|
|
|
|
};
|
|
|
|
|
2011-10-25 13:40:15 +04:00
|
|
|
v86d = callPackage ../os-specific/linux/v86d { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
virtualbox = callPackage ../applications/virtualization/virtualbox {
|
2009-04-15 16:37:57 +04:00
|
|
|
stdenv = stdenv_32bit;
|
2009-01-25 23:09:17 +03:00
|
|
|
inherit (gnome) libIDL;
|
|
|
|
};
|
2009-11-03 18:57:22 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
virtualboxGuestAdditions = callPackage ../applications/virtualization/virtualbox/guest-additions { };
|
2008-05-22 16:01:24 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
# Build the kernel modules for the some of the kernels.
|
2010-08-02 17:57:57 +04:00
|
|
|
linuxPackages_2_6_27 = recurseIntoAttrs (linuxPackagesFor linux_2_6_27 pkgs.linuxPackages_2_6_27);
|
|
|
|
linuxPackages_2_6_32 = recurseIntoAttrs (linuxPackagesFor linux_2_6_32 pkgs.linuxPackages_2_6_32);
|
2010-05-05 23:48:46 +04:00
|
|
|
linuxPackages_2_6_32_systemtap =
|
2010-08-02 17:57:57 +04:00
|
|
|
recurseIntoAttrs (linuxPackagesFor linux_2_6_32_systemtap pkgs.linuxPackages_2_6_32_systemtap);
|
2010-09-10 20:27:39 +04:00
|
|
|
linuxPackages_2_6_32_xen =
|
2010-09-14 16:15:06 +04:00
|
|
|
recurseIntoAttrs (linuxPackagesFor linux_2_6_32_xen pkgs.linuxPackages_2_6_32_xen);
|
2010-08-12 20:33:19 +04:00
|
|
|
linuxPackages_2_6_35 = recurseIntoAttrs (linuxPackagesFor linux_2_6_35 pkgs.linuxPackages_2_6_35);
|
2011-04-04 22:17:02 +04:00
|
|
|
linuxPackages_2_6_38 = recurseIntoAttrs (linuxPackagesFor linux_2_6_38 pkgs.linuxPackages_2_6_38);
|
2011-07-15 00:08:51 +04:00
|
|
|
linuxPackages_2_6_38_ati = recurseIntoAttrs (linuxPackagesFor linux_2_6_38_ati pkgs.linuxPackages_2_6_38);
|
2011-05-20 12:08:37 +04:00
|
|
|
linuxPackages_2_6_39 = recurseIntoAttrs (linuxPackagesFor linux_2_6_39 pkgs.linuxPackages_2_6_39);
|
2011-07-24 07:05:00 +04:00
|
|
|
linuxPackages_3_0 = recurseIntoAttrs (linuxPackagesFor linux_3_0 pkgs.linuxPackages_3_0);
|
2011-08-08 16:48:05 +04:00
|
|
|
linuxPackages_3_1 = recurseIntoAttrs (linuxPackagesFor linux_3_1 pkgs.linuxPackages_3_1);
|
2011-02-24 14:25:16 +03:00
|
|
|
linuxPackages_nanonote_jz_2_6_34 = recurseIntoAttrs (linuxPackagesFor linux_nanonote_jz_2_6_34 pkgs.linuxPackages_nanonote_jz_2_6_34);
|
|
|
|
linuxPackages_nanonote_jz_2_6_35 = recurseIntoAttrs (linuxPackagesFor linux_nanonote_jz_2_6_35 pkgs.linuxPackages_nanonote_jz_2_6_35);
|
|
|
|
linuxPackages_nanonote_jz_2_6_36 = recurseIntoAttrs (linuxPackagesFor linux_nanonote_jz_2_6_36 pkgs.linuxPackages_nanonote_jz_2_6_36);
|
2012-01-27 03:25:39 +04:00
|
|
|
linuxPackages_3_2 = recurseIntoAttrs (linuxPackagesFor pkgs.linux_3_2 pkgs.linuxPackages_3_2);
|
2012-03-12 06:19:05 +04:00
|
|
|
linuxPackages_3_3 = recurseIntoAttrs (linuxPackagesFor pkgs.linux_3_3 pkgs.linuxPackages_3_3);
|
2009-12-21 17:12:00 +03:00
|
|
|
|
2008-05-22 16:01:24 +04:00
|
|
|
# The current default kernel / kernel modules.
|
2011-09-02 17:41:38 +04:00
|
|
|
linux = linuxPackages.kernel;
|
2011-09-16 23:15:06 +04:00
|
|
|
linuxPackages = linuxPackages_2_6_35;
|
2008-03-24 22:40:15 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
keyutils = callPackage ../os-specific/linux/keyutils { };
|
2010-01-25 13:34:47 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libselinux = callPackage ../os-specific/linux/libselinux { };
|
2008-01-12 04:26:04 +03:00
|
|
|
|
2011-03-27 08:46:12 +04:00
|
|
|
libsemanage = callPackage ../os-specific/linux/libsemanage { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libraw1394 = callPackage ../development/libraries/libraw1394 { };
|
2008-01-12 04:26:04 +03:00
|
|
|
|
2011-02-23 13:04:50 +03:00
|
|
|
libsexy = callPackage ../development/libraries/libsexy { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libsepol = callPackage ../os-specific/linux/libsepol { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libsmbios = callPackage ../os-specific/linux/libsmbios { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2011-12-21 14:29:19 +04:00
|
|
|
lm_sensors = callPackage ../os-specific/linux/lm-sensors { };
|
2008-09-14 23:05:59 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
lsiutil = callPackage ../os-specific/linux/lsiutil { };
|
2010-07-01 17:18:09 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
klibc = callPackage ../os-specific/linux/klibc {
|
2009-12-21 17:04:45 +03:00
|
|
|
linuxHeaders = glibc.kernelHeaders;
|
2009-01-29 18:44:37 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
klibcShrunk = callPackage ../os-specific/linux/klibc/shrunk.nix { };
|
2009-01-29 18:44:37 +03:00
|
|
|
|
2010-07-28 19:39:39 +04:00
|
|
|
kvm = qemu_kvm;
|
2009-11-09 14:55:31 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libcap = callPackage ../os-specific/linux/libcap { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
2010-09-27 17:49:13 +04:00
|
|
|
libcap_progs = callPackage ../os-specific/linux/libcap/progs.nix { };
|
|
|
|
|
|
|
|
libcap_pam = callPackage ../os-specific/linux/libcap/pam.nix { };
|
|
|
|
|
|
|
|
libcap_manpages = callPackage ../os-specific/linux/libcap/man.nix { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libnscd = callPackage ../os-specific/linux/libnscd { };
|
2005-08-30 11:39:38 +04:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
libnotify = callPackage ../development/libraries/libnotify { };
|
2007-10-27 21:55:13 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
libvolume_id = callPackage ../os-specific/linux/libvolume_id { };
|
2007-05-31 17:43:13 +04:00
|
|
|
|
2011-02-23 00:07:36 +03:00
|
|
|
lsscsi = callPackage ../os-specific/linux/lsscsi { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
lvm2 = callPackage ../os-specific/linux/lvm2 { };
|
2007-10-27 21:55:13 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mdadm = callPackage ../os-specific/linux/mdadm { };
|
2005-12-19 13:34:01 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mingetty = callPackage ../os-specific/linux/mingetty { };
|
2006-01-26 17:01:08 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
module_init_tools = callPackage ../os-specific/linux/module-init-tools { };
|
2006-09-11 12:45:01 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
mountall = callPackage ../os-specific/linux/mountall {
|
2010-06-04 17:43:53 +04:00
|
|
|
automake = automake111x;
|
2008-08-06 19:43:03 +04:00
|
|
|
};
|
|
|
|
|
2008-06-19 02:48:34 +04:00
|
|
|
aggregateModules = modules:
|
2008-03-17 12:41:28 +03:00
|
|
|
import ../os-specific/linux/module-init-tools/aggregator.nix {
|
2009-04-20 23:13:40 +04:00
|
|
|
inherit stdenv module_init_tools modules buildEnv;
|
2008-03-17 12:41:28 +03:00
|
|
|
};
|
2008-01-04 20:02:12 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
modutils = callPackage ../os-specific/linux/modutils {
|
2007-12-31 01:02:04 +03:00
|
|
|
stdenv = overrideGCC stdenv gcc34;
|
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2011-04-06 18:57:31 +04:00
|
|
|
multipath_tools = callPackage ../os-specific/linux/multipath-tools { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
nettools = callPackage ../os-specific/linux/net-tools { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
neverball = callPackage ../games/neverball { };
|
2009-03-04 20:28:25 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
numactl = callPackage ../os-specific/linux/numactl { };
|
2008-04-18 18:38:27 +04:00
|
|
|
|
2012-02-28 04:10:05 +04:00
|
|
|
gogoclient = callPackage ../os-specific/linux/gogoclient { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
nss_ldap = callPackage ../os-specific/linux/nss_ldap { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pam = callPackage ../os-specific/linux/pam { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2010-01-03 14:13:05 +03:00
|
|
|
# pam_bioapi ( see http://www.thinkwiki.org/wiki/How_to_enable_the_fingerprint_reader )
|
|
|
|
|
2010-08-06 12:50:58 +04:00
|
|
|
pam_ccreds = callPackage ../os-specific/linux/pam_ccreds {
|
|
|
|
db = db4;
|
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
pam_console = callPackage ../os-specific/linux/pam_console {
|
2009-03-30 19:31:47 +04:00
|
|
|
libtool = libtool_1_5;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pam_devperm = callPackage ../os-specific/linux/pam_devperm { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2010-08-06 12:49:05 +04:00
|
|
|
pam_krb5 = callPackage ../os-specific/linux/pam_krb5 { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pam_ldap = callPackage ../os-specific/linux/pam_ldap { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pam_login = callPackage ../os-specific/linux/pam_login { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pam_unix2 = callPackage ../os-specific/linux/pam_unix2 { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pam_usb = callPackage ../os-specific/linux/pam_usb { };
|
2010-01-03 14:13:05 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
pcmciaUtils = callPackage ../os-specific/linux/pcmciautils {
|
2008-08-27 17:59:33 +04:00
|
|
|
firmware = getConfig ["pcmciaUtils" "firmware"] [];
|
2008-07-25 19:54:19 +04:00
|
|
|
config = getConfig ["pcmciaUtils" "config"] null;
|
|
|
|
};
|
|
|
|
|
2011-07-08 01:32:55 +04:00
|
|
|
phat = callPackage ../development/libraries/phat {
|
2011-04-23 01:42:38 +04:00
|
|
|
inherit (gnome) gtk libgnomecanvas;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pmount = callPackage ../os-specific/linux/pmount { };
|
2010-01-03 14:13:05 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pmutils = callPackage ../os-specific/linux/pm-utils { };
|
2009-09-26 01:43:25 +04:00
|
|
|
|
2011-03-27 08:46:19 +04:00
|
|
|
policycoreutils = callPackage ../os-specific/linux/policycoreutils { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
powertop = callPackage ../os-specific/linux/powertop { };
|
2007-12-14 01:15:03 +03:00
|
|
|
|
2011-11-09 01:07:57 +04:00
|
|
|
prayer = callPackage ../servers/prayer { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
procps = callPackage ../os-specific/linux/procps { };
|
2006-09-11 13:17:28 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pwdutils = callPackage ../os-specific/linux/pwdutils { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
qemu_kvm = callPackage ../os-specific/linux/qemu-kvm { };
|
2012-02-28 03:25:54 +04:00
|
|
|
qemu_kvm_1_0 = callPackage ../os-specific/linux/qemu-kvm/1.0.nix { };
|
2009-08-04 20:02:27 +04:00
|
|
|
|
2012-01-12 21:16:11 +04:00
|
|
|
firmwareLinuxNonfree = callPackage ../os-specific/linux/firmware/firmware-linux-nonfree { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
radeontools = callPackage ../os-specific/linux/radeontools { };
|
2005-09-11 19:38:59 +04:00
|
|
|
|
2011-07-14 23:21:23 +04:00
|
|
|
radeonR700 = callPackage ../os-specific/linux/firmware/radeon-r700 { };
|
|
|
|
radeonR600 = callPackage ../os-specific/linux/firmware/radeon-r600 { };
|
2011-08-23 17:24:44 +04:00
|
|
|
radeonJuniper = callPackage ../os-specific/linux/firmware/radeon-juniper { };
|
2011-07-14 23:21:23 +04:00
|
|
|
|
2011-10-21 04:43:56 +04:00
|
|
|
regionset = callPackage ../os-specific/linux/regionset { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rfkill = callPackage ../os-specific/linux/rfkill { };
|
2010-04-21 15:21:15 +04:00
|
|
|
|
2012-02-24 05:35:59 +04:00
|
|
|
rfkill_udev = callPackage ../os-specific/linux/rfkill/udev.nix { };
|
|
|
|
|
2012-01-06 22:42:39 +04:00
|
|
|
ralink_fw = callPackage ../os-specific/linux/firmware/ralink { };
|
|
|
|
|
2011-06-19 23:47:10 +04:00
|
|
|
rt2860fw = callPackage ../os-specific/linux/firmware/rt2860 { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rt2870fw = callPackage ../os-specific/linux/firmware/rt2870 { };
|
2010-07-09 21:30:08 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rt73fw = callPackage ../os-specific/linux/firmware/rt73 { };
|
2009-09-19 00:45:10 +04:00
|
|
|
|
2011-07-26 18:12:33 +04:00
|
|
|
rtkit = callPackage ../os-specific/linux/rtkit { };
|
|
|
|
|
2011-07-24 02:58:32 +04:00
|
|
|
rtl8192cfw = callPackage ../os-specific/linux/firmware/rtl8192c { };
|
|
|
|
|
2012-01-11 03:23:15 +04:00
|
|
|
rtl8168e2fw = callPackage ../os-specific/linux/firmware/rtl8168e-2 { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
sdparm = callPackage ../os-specific/linux/sdparm { };
|
2005-09-11 19:38:59 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
shadow = callPackage ../os-specific/linux/shadow { };
|
2005-09-11 19:38:59 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
splashutils = callPackage ../os-specific/linux/splashutils/default.nix { };
|
2009-01-29 18:56:01 +03:00
|
|
|
|
2010-09-06 11:29:18 +04:00
|
|
|
statifier = builderDefsPackage (import ../os-specific/linux/statifier) { };
|
2009-07-10 01:34:29 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
sysfsutils = callPackage ../os-specific/linux/sysfsutils { };
|
2008-07-25 19:53:23 +04:00
|
|
|
|
|
|
|
# Provided with sysfsutils.
|
|
|
|
libsysfs = sysfsutils;
|
|
|
|
systool = sysfsutils;
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
sysklogd = callPackage ../os-specific/linux/sysklogd { };
|
2005-09-11 19:38:59 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
syslinux = callPackage ../os-specific/linux/syslinux { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
sysstat = callPackage ../os-specific/linux/sysstat { };
|
2005-12-20 03:48:38 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
sysvinit = callPackage ../os-specific/linux/sysvinit { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
sysvtools = callPackage ../os-specific/linux/sysvinit {
|
2007-12-31 01:02:04 +03:00
|
|
|
withoutInitTools = true;
|
|
|
|
};
|
|
|
|
|
2008-03-16 01:41:31 +03:00
|
|
|
# FIXME: `tcp-wrapper' is actually not OS-specific.
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
tcpWrapper = callPackage ../os-specific/linux/tcp-wrapper { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
trackballs = callPackage ../games/trackballs {
|
2009-05-17 03:14:37 +04:00
|
|
|
debug = false;
|
2011-02-15 16:14:29 +03:00
|
|
|
guile = guile_1_8;
|
2009-05-17 03:14:37 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
tunctl = callPackage ../os-specific/linux/tunctl { };
|
2009-03-02 00:34:39 +03:00
|
|
|
|
2009-02-21 21:59:15 +03:00
|
|
|
/*tuxracer = builderDefsPackage (import ../games/tuxracer) {
|
|
|
|
inherit mesa tcl freeglut;
|
|
|
|
inherit (xlibs) libX11 xproto;
|
|
|
|
};*/
|
|
|
|
|
Simplified much more the expressions for cross building and multiplatform.
I introduce the new nixpkgs parameter "platform", defaulting to "pc",
which was before defined as an attribute of nixpkgs.
I made the crossSystem nixpkgs attribute set parameter contain its own 'platform'.
This allows cross-building a kernel for a given crossSystem.platform in a non-PC
platform.
The actual native platform can be taken from stdenv.platform, and this way we also
avoid the constant passing of 'platform' to packages for platform-dependant builds
(kernel, initrd, ...).
I will update nixos accordingly to these changes, for non-PC platforms to work.
I think we are gaining on flexibility and clearness. I could cross build succesfully
an ultrasparc kernel and a mipsel kernel on PC. But since this change, I should be able
to do this also in non-PC.
Before this change, there was no possibility of distinguishing the "target platform" or
the "native build platform" when cross building, being the single "platform" attribute
always interpreted as target platform.
The platform is a quite relevant attribute set, as it determines the linuxHeaders used
(in the case, by now the only one supported, of linux targets).
The platform attributes are quite linux centric still. Let's hope for more generality to come.
svn path=/nixpkgs/trunk/; revision=20273
2010-02-27 20:35:47 +03:00
|
|
|
ubootChooser = name : if (name == "upstream") then ubootUpstream
|
|
|
|
else if (name == "sheevaplug") then ubootSheevaplug
|
2011-01-15 00:44:59 +03:00
|
|
|
else if (name == "guruplug") then ubootGuruplug
|
2010-08-04 15:07:13 +04:00
|
|
|
else if (name == "nanonote") then ubootNanonote
|
Simplified much more the expressions for cross building and multiplatform.
I introduce the new nixpkgs parameter "platform", defaulting to "pc",
which was before defined as an attribute of nixpkgs.
I made the crossSystem nixpkgs attribute set parameter contain its own 'platform'.
This allows cross-building a kernel for a given crossSystem.platform in a non-PC
platform.
The actual native platform can be taken from stdenv.platform, and this way we also
avoid the constant passing of 'platform' to packages for platform-dependant builds
(kernel, initrd, ...).
I will update nixos accordingly to these changes, for non-PC platforms to work.
I think we are gaining on flexibility and clearness. I could cross build succesfully
an ultrasparc kernel and a mipsel kernel on PC. But since this change, I should be able
to do this also in non-PC.
Before this change, there was no possibility of distinguishing the "target platform" or
the "native build platform" when cross building, being the single "platform" attribute
always interpreted as target platform.
The platform is a quite relevant attribute set, as it determines the linuxHeaders used
(in the case, by now the only one supported, of linux targets).
The platform attributes are quite linux centric still. Let's hope for more generality to come.
svn path=/nixpkgs/trunk/; revision=20273
2010-02-27 20:35:47 +03:00
|
|
|
else throw "Unknown uboot";
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ubootUpstream = callPackage ../misc/uboot { };
|
2009-11-08 03:32:12 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ubootSheevaplug = callPackage ../misc/uboot/sheevaplug.nix { };
|
2010-02-17 23:53:01 +03:00
|
|
|
|
2010-08-04 15:07:13 +04:00
|
|
|
ubootNanonote = callPackage ../misc/uboot/nanonote.nix { };
|
|
|
|
|
2010-10-05 02:23:57 +04:00
|
|
|
ubootGuruplug = callPackage ../misc/uboot/guruplug.nix { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
uclibc = callPackage ../os-specific/linux/uclibc { };
|
2009-11-08 03:32:12 +03:00
|
|
|
|
2010-03-09 18:48:25 +03:00
|
|
|
uclibcCross = import ../os-specific/linux/uclibc {
|
2010-03-09 21:05:38 +03:00
|
|
|
inherit fetchurl stdenv libiconv;
|
2010-03-09 18:48:25 +03:00
|
|
|
linuxHeaders = linuxHeadersCross;
|
|
|
|
gccCross = gccCrossStageStatic;
|
|
|
|
cross = assert crossSystem != null; crossSystem;
|
2009-12-04 16:35:58 +03:00
|
|
|
};
|
|
|
|
|
2011-07-11 18:00:17 +04:00
|
|
|
udev145 = callPackage ../os-specific/linux/udev/145.nix { };
|
2011-08-18 17:04:55 +04:00
|
|
|
udev173 = callPackage ../os-specific/linux/udev/173.nix { };
|
|
|
|
udev = pkgs.udev173;
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2012-03-01 19:09:53 +04:00
|
|
|
udisks = callPackage ../os-specific/linux/udisks { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2012-02-18 03:47:00 +04:00
|
|
|
uml = linux.override {
|
2007-12-31 01:02:04 +03:00
|
|
|
userModeLinux = true;
|
|
|
|
};
|
2007-09-11 23:27:25 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
umlutilities = callPackage ../os-specific/linux/uml-utilities {
|
2008-07-26 05:02:27 +04:00
|
|
|
tunctl = true; mconsole = true;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2005-10-04 18:25:13 +04:00
|
|
|
|
2011-10-06 17:16:47 +04:00
|
|
|
untie = callPackage ../os-specific/linux/untie { };
|
2010-11-23 10:52:57 +03:00
|
|
|
|
2011-12-14 22:22:34 +04:00
|
|
|
upower = callPackage ../os-specific/linux/upower { };
|
2011-08-10 19:51:20 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
upstart = callPackage ../os-specific/linux/upstart { };
|
2009-10-30 21:12:28 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
usbutils = callPackage ../os-specific/linux/usbutils { };
|
2007-11-11 19:52:29 +03:00
|
|
|
|
2011-12-12 23:56:17 +04:00
|
|
|
utillinux = lowPrio (callPackage ../os-specific/linux/util-linux {
|
2010-07-28 16:52:54 +04:00
|
|
|
ncurses = null;
|
2011-07-09 03:11:38 +04:00
|
|
|
perl = null;
|
2011-07-13 14:50:22 +04:00
|
|
|
});
|
2009-01-06 12:28:45 +03:00
|
|
|
|
2011-12-12 23:56:17 +04:00
|
|
|
utillinuxCurses = utillinux.override {
|
2011-07-09 03:11:41 +04:00
|
|
|
inherit ncurses perl;
|
2009-01-07 02:22:29 +03:00
|
|
|
};
|
|
|
|
|
2011-08-13 12:59:00 +04:00
|
|
|
v4l_utils = callPackage ../os-specific/linux/v4l-utils {};
|
|
|
|
|
2010-05-06 23:19:22 +04:00
|
|
|
windows = rec {
|
2010-08-03 01:40:34 +04:00
|
|
|
w32api = callPackage ../os-specific/windows/w32api {
|
2010-05-06 23:19:22 +04:00
|
|
|
gccCross = gccCrossStageStatic;
|
2010-08-19 16:37:10 +04:00
|
|
|
binutilsCross = binutilsCross;
|
|
|
|
};
|
2010-05-06 22:22:51 +04:00
|
|
|
|
2010-05-06 23:19:22 +04:00
|
|
|
w32api_headers = w32api.override {
|
|
|
|
onlyHeaders = true;
|
|
|
|
};
|
2010-05-06 22:22:51 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
mingw_runtime = callPackage ../os-specific/windows/mingwrt {
|
2010-05-06 23:19:22 +04:00
|
|
|
gccCross = gccCrossMingw2;
|
|
|
|
binutilsCross = binutilsCross;
|
|
|
|
};
|
2010-05-06 22:22:51 +04:00
|
|
|
|
2010-05-06 23:19:22 +04:00
|
|
|
mingw_runtime_headers = mingw_runtime.override {
|
|
|
|
onlyHeaders = true;
|
|
|
|
};
|
2010-05-06 22:22:51 +04:00
|
|
|
|
2010-05-06 23:19:22 +04:00
|
|
|
mingw_headers1 = buildEnv {
|
|
|
|
name = "mingw-headers-1";
|
|
|
|
paths = [ w32api_headers mingw_runtime_headers ];
|
|
|
|
};
|
2010-05-06 22:22:51 +04:00
|
|
|
|
2010-05-06 23:19:22 +04:00
|
|
|
mingw_headers2 = buildEnv {
|
|
|
|
name = "mingw-headers-2";
|
|
|
|
paths = [ w32api mingw_runtime_headers ];
|
|
|
|
};
|
|
|
|
|
|
|
|
mingw_headers3 = buildEnv {
|
|
|
|
name = "mingw-headers-3";
|
|
|
|
paths = [ w32api mingw_runtime ];
|
|
|
|
};
|
2010-05-06 22:22:51 +04:00
|
|
|
|
2012-01-30 13:53:45 +04:00
|
|
|
pthreads = callPackage ../os-specific/windows/pthread-w32 {
|
|
|
|
mingw_headers = mingw_headers2;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
wxMSW = callPackage ../os-specific/windows/wxMSW-2.8 { };
|
2010-05-06 22:22:51 +04:00
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
wesnoth = callPackage ../games/wesnoth {
|
2009-12-25 23:56:37 +03:00
|
|
|
inherit (gtkLibs) pango;
|
2010-11-13 14:50:43 +03:00
|
|
|
lua = lua5;
|
2011-11-22 10:13:18 +04:00
|
|
|
boost = boost147;
|
2008-02-07 00:26:17 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
wirelesstools = callPackage ../os-specific/linux/wireless-tools { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
2012-01-28 18:39:56 +04:00
|
|
|
wpa_supplicant = callPackage ../os-specific/linux/wpa_supplicant { };
|
2007-07-17 23:29:53 +04:00
|
|
|
|
2012-02-20 18:26:01 +04:00
|
|
|
wpa_supplicant_gui = callPackage ../os-specific/linux/wpa_supplicant/gui.nix { };
|
2009-05-12 22:52:48 +04:00
|
|
|
|
2011-08-08 05:20:29 +04:00
|
|
|
xf86_input_multitouch =
|
|
|
|
callPackage ../os-specific/linux/xf86-input-multitouch { };
|
2009-05-12 22:52:48 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xf86_input_wacom = callPackage ../os-specific/linux/xf86-input-wacom { };
|
2010-04-12 02:42:28 +04:00
|
|
|
|
2008-11-30 19:50:05 +03:00
|
|
|
xmoto = builderDefsPackage (import ../games/xmoto) {
|
|
|
|
inherit chipmunk sqlite curl zlib bzip2 libjpeg libpng
|
|
|
|
freeglut mesa SDL SDL_mixer SDL_image SDL_net SDL_ttf
|
2012-01-09 03:31:31 +04:00
|
|
|
lua5 ode libxdg_basedir libxml2;
|
2008-11-30 19:50:05 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xorg_sys_opengl = callPackage ../os-specific/linux/opengl/xorg-sys { };
|
2007-08-20 17:48:56 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
zd1211fw = callPackage ../os-specific/linux/firmware/zd1211 { };
|
2005-05-27 00:09:29 +04:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
### DATA
|
2005-08-30 11:39:38 +04:00
|
|
|
|
2010-11-06 12:45:13 +03:00
|
|
|
andagii = callPackage ../data/fonts/andagii {};
|
|
|
|
|
2010-11-24 14:51:50 +03:00
|
|
|
anonymousPro = callPackage ../data/fonts/anonymous-pro {};
|
|
|
|
|
2008-07-05 09:26:58 +04:00
|
|
|
arkpandora_ttf = builderDefsPackage (import ../data/fonts/arkpandora) {
|
2008-08-15 02:04:30 +04:00
|
|
|
};
|
2006-09-15 19:28:53 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
bakoma_ttf = callPackage ../data/fonts/bakoma-ttf { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cacert = callPackage ../data/misc/cacert { };
|
2010-01-20 17:10:26 +03:00
|
|
|
|
2012-01-07 00:10:23 +04:00
|
|
|
cantarell_fonts = callPackage ../data/fonts/cantarell-fonts { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
corefonts = callPackage ../data/fonts/corefonts { };
|
2007-12-06 00:25:47 +03:00
|
|
|
|
2007-12-31 01:02:04 +03:00
|
|
|
wrapFonts = paths : ((import ../data/fonts/fontWrap) {
|
2010-11-11 15:27:39 +03:00
|
|
|
inherit fetchurl stdenv builderDefs paths;
|
2007-12-31 01:02:04 +03:00
|
|
|
inherit (xorg) mkfontdir mkfontscale;
|
|
|
|
});
|
2007-11-22 07:23:27 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
clearlyU = callPackage ../data/fonts/clearlyU { };
|
2008-03-02 21:41:32 +03:00
|
|
|
|
2011-05-28 23:51:08 +04:00
|
|
|
cm_unicode = callPackage ../data/fonts/cm-unicode {};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
dejavu_fonts = callPackage ../data/fonts/dejavu-fonts {
|
2009-04-20 16:49:35 +04:00
|
|
|
inherit (perlPackages) FontTTF;
|
2008-03-02 21:41:32 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
docbook5 = callPackage ../data/sgml+xml/schemas/docbook-5.0 { };
|
2007-11-22 07:23:27 +03:00
|
|
|
|
2011-11-01 20:47:18 +04:00
|
|
|
docbook_sgml_dtd_41 = callPackage ../data/sgml+xml/schemas/sgml-dtd/docbook/4.1.nix { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
docbook_xml_dtd_412 = callPackage ../data/sgml+xml/schemas/xml-dtd/docbook/4.1.2.nix { };
|
2007-09-03 16:10:57 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
docbook_xml_dtd_42 = callPackage ../data/sgml+xml/schemas/xml-dtd/docbook/4.2.nix { };
|
2005-10-22 15:51:30 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
docbook_xml_dtd_43 = callPackage ../data/sgml+xml/schemas/xml-dtd/docbook/4.3.nix { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
docbook_xml_dtd_45 = callPackage ../data/sgml+xml/schemas/xml-dtd/docbook/4.5.nix { };
|
2009-11-03 18:57:27 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
docbook_xml_ebnf_dtd = callPackage ../data/sgml+xml/schemas/xml-dtd/docbook-ebnf { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
|
|
|
docbook_xml_xslt = docbook_xsl;
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
docbook_xsl = callPackage ../data/sgml+xml/stylesheets/xslt/docbook-xsl { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2009-07-14 19:02:56 +04:00
|
|
|
docbook5_xsl = docbook_xsl_ns;
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
docbook_xsl_ns = callPackage ../data/sgml+xml/stylesheets/xslt/docbook-xsl-ns { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
freefont_ttf = callPackage ../data/fonts/freefont-ttf { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2011-05-28 23:01:59 +04:00
|
|
|
gentium = callPackage ../data/fonts/gentium {};
|
|
|
|
|
2012-03-09 02:45:58 +04:00
|
|
|
gsettings_desktop_schemas = callPackage ../data/misc/gsettings-desktop-schemas {};
|
|
|
|
|
2010-08-09 22:00:08 +04:00
|
|
|
hicolor_icon_theme = callPackage ../data/misc/hicolor-icon-theme { };
|
2010-08-11 19:49:42 +04:00
|
|
|
|
2010-11-24 14:19:38 +03:00
|
|
|
inconsolata = callPackage ../data/fonts/inconsolata {};
|
|
|
|
|
2010-08-09 22:00:08 +04:00
|
|
|
junicode = callPackage ../data/fonts/junicode { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
liberation_ttf = callPackage ../data/fonts/redhat-liberation-fonts { };
|
2008-03-02 21:41:32 +03:00
|
|
|
|
2011-05-24 19:13:54 +04:00
|
|
|
libertine = builderDefsPackage (import ../data/fonts/libertine) {
|
2008-04-28 14:10:44 +04:00
|
|
|
inherit fontforge;
|
2008-08-15 02:04:30 +04:00
|
|
|
};
|
2008-04-28 14:10:44 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
lmodern = callPackage ../data/fonts/lmodern { };
|
2008-04-26 19:23:46 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
manpages = callPackage ../data/documentation/man-pages { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
miscfiles = callPackage ../data/misc/miscfiles { };
|
2009-10-27 02:03:36 +03:00
|
|
|
|
2012-01-06 03:25:28 +04:00
|
|
|
mobile_broadband_provider_info = callPackage ../data/misc/mobile-broadband-provider-info { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mph_2b_damase = callPackage ../data/fonts/mph-2b-damase { };
|
2008-03-02 21:41:32 +03:00
|
|
|
|
2011-05-28 19:46:09 +04:00
|
|
|
oldstandard = callPackage ../data/fonts/oldstandard { };
|
|
|
|
|
2011-03-24 15:05:34 +03:00
|
|
|
posix_man_pages = callPackage ../data/documentation/man-pages-posix { };
|
2011-03-24 14:44:43 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pthreadmanpages = callPackage ../data/documentation/pthread-man-pages { };
|
2009-04-02 18:30:34 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
shared_mime_info = callPackage ../data/misc/shared-mime-info { };
|
2010-03-16 15:13:40 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
shared_desktop_ontologies = callPackage ../data/misc/shared-desktop-ontologies { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
stdmanpages = callPackage ../data/documentation/std-man-pages { };
|
2009-03-30 12:14:19 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
iana_etc = callPackage ../data/misc/iana-etc { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2011-09-19 12:35:30 +04:00
|
|
|
poppler_data = callPackage ../data/misc/poppler-data { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
r3rs = callPackage ../data/documentation/rnrs/r3rs.nix { };
|
2008-03-27 17:40:08 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
r4rs = callPackage ../data/documentation/rnrs/r4rs.nix { };
|
2008-03-27 17:40:08 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
r5rs = callPackage ../data/documentation/rnrs/r5rs.nix { };
|
2008-03-27 17:40:08 +03:00
|
|
|
|
2009-01-09 01:21:32 +03:00
|
|
|
themes = name: import (../data/misc/themes + ("/" + name + ".nix")) {
|
|
|
|
inherit fetchurl;
|
|
|
|
};
|
|
|
|
|
2011-05-28 19:59:45 +04:00
|
|
|
theano = callPackage ../data/fonts/theano { };
|
|
|
|
|
2011-05-28 20:04:02 +04:00
|
|
|
tempora_lgc = callPackage ../data/fonts/tempora-lgc { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
terminus_font = callPackage ../data/fonts/terminus-font { };
|
2010-02-07 01:28:39 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ttf_bitstream_vera = callPackage ../data/fonts/ttf-bitstream-vera { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ucsFonts = callPackage ../data/fonts/ucs-fonts { };
|
2008-03-02 22:19:34 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
unifont = callPackage ../data/fonts/unifont { };
|
2008-03-02 21:41:32 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
vistafonts = callPackage ../data/fonts/vista-fonts { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
wqy_zenhei = callPackage ../data/fonts/wqy-zenhei { };
|
2008-03-02 21:41:32 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xhtml1 = callPackage ../data/sgml+xml/schemas/xml-dtd/xhtml1 { };
|
2009-09-16 16:25:22 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xkeyboard_config = callPackage ../data/misc/xkeyboard-config { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
|
|
|
|
|
|
|
### APPLICATIONS
|
|
|
|
|
|
|
|
|
2010-08-11 17:25:30 +04:00
|
|
|
aangifte2005 = callPackage_i686 ../applications/taxes/aangifte-2005 { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2010-08-11 17:25:30 +04:00
|
|
|
aangifte2006 = callPackage_i686 ../applications/taxes/aangifte-2006 { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2010-08-11 17:25:30 +04:00
|
|
|
aangifte2007 = callPackage_i686 ../applications/taxes/aangifte-2007 { };
|
2008-03-16 00:45:57 +03:00
|
|
|
|
2010-08-11 17:25:30 +04:00
|
|
|
aangifte2008 = callPackage_i686 ../applications/taxes/aangifte-2008 { };
|
2010-03-25 22:40:19 +03:00
|
|
|
|
2010-08-11 17:25:30 +04:00
|
|
|
aangifte2009 = callPackage_i686 ../applications/taxes/aangifte-2009 { };
|
2008-03-16 00:45:57 +03:00
|
|
|
|
2011-03-23 19:06:36 +03:00
|
|
|
aangifte2010 = callPackage_i686 ../applications/taxes/aangifte-2010 { };
|
|
|
|
|
2012-03-10 23:23:04 +04:00
|
|
|
aangifte2011 = callPackage_i686 ../applications/taxes/aangifte-2011 { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
abcde = callPackage ../applications/audio/abcde { };
|
2008-05-27 00:54:34 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
abiword = callPackage ../applications/office/abiword {
|
2009-12-25 18:45:06 +03:00
|
|
|
inherit (gnome) libglade libgnomecanvas;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
|
|
|
|
2011-03-28 19:46:10 +04:00
|
|
|
adobeReader = callPackage_i686 ../applications/misc/adobe-reader { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2011-11-14 13:59:30 +04:00
|
|
|
amsn = callPackage ../applications/networking/instant-messengers/amsn { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2011-08-31 15:55:51 +04:00
|
|
|
antiword = callPackage ../applications/office/antiword {};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
ardour = callPackage ../applications/audio/ardour {
|
2009-09-21 13:58:41 +04:00
|
|
|
inherit (gtkLibs) glib pango gtk glibmm gtkmm;
|
2009-10-14 19:32:37 +04:00
|
|
|
inherit (gnome) libgnomecanvas;
|
2009-09-21 13:58:41 +04:00
|
|
|
};
|
|
|
|
|
2011-05-01 18:45:52 +04:00
|
|
|
ardour3 = lowPrio (callPackage ../applications/audio/ardour/ardour3.nix {
|
|
|
|
inherit (gtkLibs) glib pango gtk glibmm gtkmm;
|
|
|
|
inherit (gnome) libgnomecanvas libgnomecanvasmm;
|
|
|
|
});
|
|
|
|
|
2010-09-21 02:16:16 +04:00
|
|
|
arora = callPackage ../applications/networking/browsers/arora { };
|
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
audacious = callPackage ../applications/audio/audacious { };
|
2008-03-03 13:55:20 +03:00
|
|
|
|
2011-07-08 01:32:55 +04:00
|
|
|
audacity = callPackage ../applications/audio/audacity {
|
2011-04-24 17:13:57 +04:00
|
|
|
portaudio = portaudioSVN;
|
2011-08-01 15:57:46 +04:00
|
|
|
ffmpeg = ffmpeg_0_6_90;
|
2011-04-24 17:13:57 +04:00
|
|
|
};
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
aumix = callPackage ../applications/audio/aumix {
|
2008-02-12 00:45:52 +03:00
|
|
|
gtkGUI = false;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
autopanosiftc = callPackage ../applications/graphics/autopanosiftc { };
|
2009-04-07 23:15:53 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
avidemux = callPackage ../applications/video/avidemux {
|
2009-11-24 11:27:18 +03:00
|
|
|
};
|
|
|
|
|
2011-08-15 22:05:39 +04:00
|
|
|
avogadro = callPackage ../applications/science/chemistry/avogadro { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
awesome = callPackage ../applications/window-managers/awesome {
|
2010-03-04 17:44:56 +03:00
|
|
|
inherit (gtkLibs) glib pango;
|
|
|
|
lua = lua5;
|
2010-08-21 23:27:31 +04:00
|
|
|
cairo = cairo.override { xcbSupport = true; };
|
2010-03-04 17:44:56 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
batik = callPackage ../applications/graphics/batik { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2011-03-28 19:47:50 +04:00
|
|
|
bazaar = callPackage ../applications/version-management/bazaar { };
|
2008-01-18 13:29:58 +03:00
|
|
|
|
2008-05-26 15:39:08 +04:00
|
|
|
bazaarTools = builderDefsPackage (import ../applications/version-management/bazaar/tools.nix) {
|
|
|
|
inherit bazaar;
|
2008-08-15 02:04:30 +04:00
|
|
|
};
|
2008-05-26 15:39:08 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
beast = callPackage ../applications/audio/beast {
|
2008-08-18 14:50:16 +04:00
|
|
|
inherit (gnome) libgnomecanvas libart_lgpl;
|
2011-02-15 16:14:29 +03:00
|
|
|
guile = guile_1_8;
|
2008-08-18 14:50:16 +04:00
|
|
|
};
|
|
|
|
|
2011-08-26 17:49:23 +04:00
|
|
|
bibletime = callPackage ../applications/misc/bibletime { };
|
2008-09-26 13:03:22 +04:00
|
|
|
|
2011-04-13 21:53:07 +04:00
|
|
|
bitcoin = callPackage ../applications/misc/bitcoin {
|
2011-09-03 00:19:42 +04:00
|
|
|
boost = boost144;
|
2011-11-24 23:48:20 +04:00
|
|
|
db4 = db48;
|
2011-03-27 10:44:34 +04:00
|
|
|
};
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2011-09-22 23:46:39 +04:00
|
|
|
bitlbee = callPackage ../applications/networking/instant-messengers/bitlbee {
|
|
|
|
# For some reason, TLS support is broken when using GnuTLS 3.0 (can't
|
|
|
|
# connect to jabber.org, for instance.)
|
|
|
|
gnutls = gnutls2;
|
|
|
|
};
|
2008-02-21 02:02:41 +03:00
|
|
|
|
2012-02-27 00:47:12 +04:00
|
|
|
blender = callPackage ../applications/misc/blender {
|
2011-04-20 00:17:17 +04:00
|
|
|
python = python32;
|
2012-02-27 00:47:12 +04:00
|
|
|
};
|
2007-12-31 01:02:04 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
bvi = callPackage ../applications/editors/bvi { };
|
2008-01-21 01:47:08 +03:00
|
|
|
|
2011-03-28 15:50:47 +04:00
|
|
|
calibre = callPackage ../applications/misc/calibre { };
|
2010-01-08 01:47:30 +03:00
|
|
|
|
2009-11-18 12:39:59 +03:00
|
|
|
carrier = builderDefsPackage (import ../applications/networking/instant-messengers/carrier/2.5.0.nix) {
|
2008-06-16 17:15:55 +04:00
|
|
|
inherit fetchurl stdenv pkgconfig perl perlXMLParser libxml2 openssl nss
|
|
|
|
gtkspell aspell gettext ncurses avahi dbus dbus_glib python
|
2008-07-01 12:31:48 +04:00
|
|
|
libtool automake autoconf;
|
2008-06-16 17:15:55 +04:00
|
|
|
GStreamer = gst_all.gstreamer;
|
|
|
|
inherit (gtkLibs) gtk glib;
|
|
|
|
inherit (gnome) startupnotification GConf ;
|
|
|
|
inherit (xlibs) libXScrnSaver scrnsaverproto libX11 xproto kbproto;
|
2008-08-15 02:04:30 +04:00
|
|
|
};
|
2008-06-16 17:15:55 +04:00
|
|
|
funpidgin = carrier;
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cddiscid = callPackage ../applications/audio/cd-discid { };
|
2008-05-27 00:18:45 +04:00
|
|
|
|
2008-02-22 06:06:12 +03:00
|
|
|
cdparanoia = cdparanoiaIII;
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cdparanoiaIII = callPackage ../applications/audio/cdparanoia { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cdrtools = callPackage ../applications/misc/cdrtools { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2012-01-12 22:55:08 +04:00
|
|
|
centerim = callPackage ../applications/networking/instant-messengers/centerim { };
|
|
|
|
|
2011-10-07 13:26:03 +04:00
|
|
|
chatzilla = callPackage ../applications/networking/irc/chatzilla {
|
|
|
|
xulrunner = firefox36Pkgs.xulrunner;
|
|
|
|
};
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2012-01-13 17:43:15 +04:00
|
|
|
chrome = lowPrio (callPackage ../applications/networking/browsers/chromium {
|
2009-10-30 11:45:58 +03:00
|
|
|
inherit (gnome) GConf;
|
2012-03-05 02:47:52 +04:00
|
|
|
libpng = libpng12;
|
2012-01-13 17:43:15 +04:00
|
|
|
});
|
2009-10-30 11:45:58 +03:00
|
|
|
|
2011-10-06 17:52:54 +04:00
|
|
|
chromeWrapper = wrapFirefox
|
|
|
|
{ browser = chrome; browserName = "chrome"; desktopName = "Chrome";
|
|
|
|
icon = "${chrome}/libexec/chrome/product_logo_48.png";
|
|
|
|
};
|
2009-10-30 15:28:44 +03:00
|
|
|
|
2012-03-11 18:07:19 +04:00
|
|
|
cinelerra = callPackage ../applications/video/cinelerra { };
|
2008-10-14 18:01:50 +04:00
|
|
|
|
2010-11-17 18:20:57 +03:00
|
|
|
cmus = callPackage ../applications/audio/cmus { };
|
|
|
|
|
2010-10-20 03:22:24 +04:00
|
|
|
compiz = callPackage ../applications/window-managers/compiz/core.nix { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2010-10-20 03:22:24 +04:00
|
|
|
compiz_ccsm = callPackage ../applications/window-managers/compiz/ccsm.nix { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2010-10-20 03:22:24 +04:00
|
|
|
compizconfig_python = callPackage ../applications/window-managers/compiz/config-python.nix { };
|
2008-06-19 02:48:34 +04:00
|
|
|
|
2010-10-20 03:22:24 +04:00
|
|
|
libcompizconfig = callPackage ../applications/window-managers/compiz/libcompizconfig.nix { };
|
|
|
|
|
|
|
|
compiz_bcop = callPackage ../applications/window-managers/compiz/bcop.nix { };
|
|
|
|
|
|
|
|
compiz_plugins_main = callPackage ../applications/window-managers/compiz/plugins-main.nix { };
|
|
|
|
|
|
|
|
compiz_plugins_extra = callPackage ../applications/window-managers/compiz/plugins-extra.nix { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2012-01-03 14:32:56 +04:00
|
|
|
cinepaint = callPackage ../applications/graphics/cinepaint { };
|
2009-04-02 19:20:19 +04:00
|
|
|
|
2009-11-18 12:39:59 +03:00
|
|
|
codeville = builderDefsPackage (import ../applications/version-management/codeville/0.8.0.nix) {
|
2008-10-16 00:01:39 +04:00
|
|
|
inherit makeWrapper;
|
|
|
|
python = pythonFull;
|
2008-08-15 02:04:30 +04:00
|
|
|
};
|
2008-05-26 11:47:07 +04:00
|
|
|
|
2011-09-19 09:16:32 +04:00
|
|
|
comical = callPackage ../applications/graphics/comical { };
|
2009-02-09 23:44:26 +03:00
|
|
|
|
2011-10-07 13:26:03 +04:00
|
|
|
conkeror = callPackage ../applications/networking/browsers/conkeror { };
|
2010-04-24 21:34:58 +04:00
|
|
|
|
2009-02-09 23:37:11 +03:00
|
|
|
cuneiform = builderDefsPackage (import ../tools/graphics/cuneiform) {
|
|
|
|
inherit cmake patchelf;
|
|
|
|
imagemagick=imagemagick;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cvs = callPackage ../applications/version-management/cvs { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cvsps = callPackage ../applications/version-management/cvsps { };
|
2008-03-13 13:02:57 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cvs2svn = callPackage ../applications/version-management/cvs2svn { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
d4x = callPackage ../applications/misc/d4x { };
|
2008-06-19 02:48:34 +04:00
|
|
|
|
2010-07-22 22:47:59 +04:00
|
|
|
darcs = haskellPackages.darcs;
|
2008-02-09 16:52:41 +03:00
|
|
|
|
2011-02-24 14:25:16 +03:00
|
|
|
darktable = callPackage ../applications/graphics/darktable {
|
2011-07-31 15:11:52 +04:00
|
|
|
inherit (gnome) GConf gnome_keyring libglade atk;
|
|
|
|
inherit (xlibs) libxcb pixman libpthreadstubs libXau;
|
2011-01-09 00:55:33 +03:00
|
|
|
};
|
|
|
|
|
2011-09-20 10:31:37 +04:00
|
|
|
dia = callPackage ../applications/graphics/dia {
|
|
|
|
inherit (pkgs.gnome) libart_lgpl libgnomeui;
|
|
|
|
};
|
2010-10-05 21:44:05 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
djvulibre = callPackage ../applications/misc/djvulibre { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2012-02-10 14:13:44 +04:00
|
|
|
djview = callPackage ../applications/graphics/djview { };
|
|
|
|
djview4 = pkgs.djview;
|
2007-12-31 01:02:04 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dmenu = callPackage ../applications/misc/dmenu { };
|
2008-08-07 00:39:01 +04:00
|
|
|
|
2008-11-13 16:31:10 +03:00
|
|
|
dmtx = builderDefsPackage (import ../tools/graphics/dmtx) {
|
2009-03-24 13:31:39 +03:00
|
|
|
inherit libpng libtiff libjpeg imagemagick librsvg
|
2010-03-16 15:13:40 +03:00
|
|
|
pkgconfig bzip2 zlib libtool freetype fontconfig
|
2011-06-08 12:11:24 +04:00
|
|
|
ghostscript jasper xz;
|
2009-03-19 16:59:00 +03:00
|
|
|
inherit (xlibs) libX11;
|
2008-11-13 16:31:10 +03:00
|
|
|
};
|
|
|
|
|
2011-12-07 03:00:46 +04:00
|
|
|
dvb_apps = callPackage ../applications/video/dvb-apps { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dvdauthor = callPackage ../applications/video/dvdauthor { };
|
2009-01-14 19:23:06 +03:00
|
|
|
|
2012-01-09 03:27:45 +04:00
|
|
|
dvswitch = callPackage ../applications/video/dvswitch {
|
|
|
|
inherit (gtkLibs) gtkmm;
|
|
|
|
inherit (xlibs) libXau libXdmcp libXv libpthreadstubs pixman;
|
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
dwm = callPackage ../applications/window-managers/dwm {
|
2010-03-06 00:49:29 +03:00
|
|
|
patches = getConfig [ "dwm" "patches" ] [];
|
2008-10-09 14:10:49 +04:00
|
|
|
};
|
2008-08-22 00:44:08 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
eaglemode = callPackage ../applications/misc/eaglemode { };
|
2008-10-26 20:45:14 +03:00
|
|
|
|
2011-04-12 00:29:47 +04:00
|
|
|
eclipses = recurseIntoAttrs (callPackage ../applications/editors/eclipse { });
|
2009-11-03 14:00:18 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ed = callPackage ../applications/editors/ed { };
|
2008-04-25 20:13:36 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
elinks = callPackage ../applications/networking/browsers/elinks { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
elvis = callPackage ../applications/editors/elvis { };
|
2009-04-16 23:28:42 +04:00
|
|
|
|
2009-11-19 20:36:43 +03:00
|
|
|
emacs = emacs23;
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
emacs22 = callPackage ../applications/editors/emacs-22 {
|
2010-11-09 12:14:12 +03:00
|
|
|
/* Using cpp 4.5, we get:
|
|
|
|
|
|
|
|
make[1]: Entering directory `/tmp/nix-build-dhbj8qqmqxwp3iw6sjcgafsrwlwrix1f-emacs-22.3.drv-0/emacs-22.3/lib-src'
|
|
|
|
Makefile:148: *** recipe commences before first target. Stop.
|
|
|
|
|
|
|
|
Apparently, this is because `lib-src/Makefile' is generated by
|
|
|
|
processing `lib-src/Makefile.in' with cpp, and the escaping rules for
|
|
|
|
literal backslashes have changed. */
|
|
|
|
stdenv = overrideGCC stdenv gcc44;
|
2010-12-29 00:07:35 +03:00
|
|
|
xaw3dSupport = getConfig [ "emacs" "xaw3dSupport" ] false;
|
|
|
|
gtkGUI = getConfig [ "emacs" "gtkSupport" ] true;
|
2009-11-22 19:29:15 +03:00
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
emacs23 = callPackage ../applications/editors/emacs-23 {
|
2010-05-19 16:26:21 +04:00
|
|
|
# use override to select the appropriate gui toolkit
|
|
|
|
libXaw = if stdenv.isDarwin then xlibs.libXaw else null;
|
|
|
|
Xaw3d = null;
|
2010-05-28 17:59:57 +04:00
|
|
|
gtk = if stdenv.isDarwin then null else gtkLibs.gtk;
|
2010-05-19 16:26:21 +04:00
|
|
|
# TODO: these packages don't build on Darwin.
|
2011-02-11 21:02:16 +03:00
|
|
|
gconf = null /* if stdenv.isDarwin then null else gnome.GConf */;
|
|
|
|
librsvg = null /* if stdenv.isDarwin then null else librsvg */;
|
2009-08-01 02:25:05 +04:00
|
|
|
};
|
|
|
|
|
2012-01-21 22:28:57 +04:00
|
|
|
emacs24 = lowPrio (callPackage ../applications/editors/emacs-24 {
|
|
|
|
# use override to select the appropriate gui toolkit
|
|
|
|
libXaw = if stdenv.isDarwin then xlibs.libXaw else null;
|
|
|
|
Xaw3d = null;
|
|
|
|
gtk = if stdenv.isDarwin then null else gtkLibs.gtk;
|
|
|
|
# TODO: these packages don't build on Darwin.
|
|
|
|
gconf = null /* if stdenv.isDarwin then null else gnome.GConf */;
|
|
|
|
librsvg = if stdenv.isDarwin then null else librsvg;
|
2012-01-23 04:55:48 +04:00
|
|
|
# alsa only on linux
|
|
|
|
alsaLib = if stdenv.isLinux then alsaLib else null;
|
|
|
|
imagemagick = imagemagickBig;
|
2008-09-26 01:38:16 +04:00
|
|
|
});
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2010-08-02 20:01:55 +04:00
|
|
|
emacsPackages = emacs: self: let callPackage = newScope self; in rec {
|
2010-08-13 11:55:57 +04:00
|
|
|
inherit emacs;
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
bbdb = callPackage ../applications/editors/emacs-modes/bbdb { };
|
2009-06-28 03:09:21 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cedet = callPackage ../applications/editors/emacs-modes/cedet { };
|
2009-07-10 20:17:06 +04:00
|
|
|
|
2012-02-07 21:39:51 +04:00
|
|
|
calfw = callPackage ../applications/editors/emacs-modes/calfw { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cua = callPackage ../applications/editors/emacs-modes/cua { };
|
2009-07-10 20:17:06 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ecb = callPackage ../applications/editors/emacs-modes/ecb { };
|
2009-07-10 20:17:06 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jabber = callPackage ../applications/editors/emacs-modes/jabber { };
|
2010-05-17 00:32:21 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
emacsSessionManagement = callPackage ../applications/editors/emacs-modes/session-management-for-emacs { };
|
2009-07-10 20:17:06 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
emacsw3m = callPackage ../applications/editors/emacs-modes/emacs-w3m { };
|
2009-07-10 20:17:06 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
emms = callPackage ../applications/editors/emacs-modes/emms { };
|
2009-07-09 19:56:40 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
jdee = callPackage ../applications/editors/emacs-modes/jdee {
|
2009-07-10 20:17:06 +04:00
|
|
|
# Requires Emacs 23, for `avl-tree'.
|
|
|
|
};
|
|
|
|
|
2012-02-07 21:40:02 +04:00
|
|
|
js2 = callPackage ../applications/editors/emacs-modes/js2 { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
stratego = callPackage ../applications/editors/emacs-modes/stratego { };
|
2009-09-01 18:27:24 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
haskellMode = callPackage ../applications/editors/emacs-modes/haskell { };
|
2009-07-10 20:17:06 +04:00
|
|
|
|
2012-02-29 16:53:13 +04:00
|
|
|
ocamlMode = callPackage ../applications/editors/emacs-modes/ocaml { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
hol_light_mode = callPackage ../applications/editors/emacs-modes/hol_light { };
|
2010-02-15 14:00:02 +03:00
|
|
|
|
2010-08-24 12:25:51 +04:00
|
|
|
htmlize = callPackage ../applications/editors/emacs-modes/htmlize { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
magit = callPackage ../applications/editors/emacs-modes/magit { };
|
2009-07-10 20:17:06 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
maudeMode = callPackage ../applications/editors/emacs-modes/maude { };
|
2009-07-10 20:17:06 +04:00
|
|
|
|
2012-01-21 22:29:14 +04:00
|
|
|
notmuch = callPackage ../applications/networking/mailreaders/notmuch { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
nxml = callPackage ../applications/editors/emacs-modes/nxml { };
|
2009-07-10 20:17:06 +04:00
|
|
|
|
2010-07-22 12:59:46 +04:00
|
|
|
# This is usually a newer version of Org-Mode than that found in GNU Emacs, so
|
|
|
|
# we want it to have higher precedence.
|
2010-09-06 11:58:13 +04:00
|
|
|
org = hiPrio (callPackage ../applications/editors/emacs-modes/org { });
|
2010-07-22 12:59:12 +04:00
|
|
|
|
2010-12-21 07:40:38 +03:00
|
|
|
phpMode = callPackage ../applications/editors/emacs-modes/php { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
prologMode = callPackage ../applications/editors/emacs-modes/prolog { };
|
2009-12-11 19:18:27 +03:00
|
|
|
|
2012-01-23 23:03:41 +04:00
|
|
|
proofgeneral = callPackage ../applications/editors/emacs-modes/proofgeneral {
|
|
|
|
texLive = pkgs.texLiveAggregationFun {
|
|
|
|
paths = [ pkgs.texLive pkgs.texLiveCMSuper ];
|
|
|
|
};
|
|
|
|
};
|
2009-07-10 20:17:06 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
quack = callPackage ../applications/editors/emacs-modes/quack { };
|
2009-10-20 19:12:29 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
remember = callPackage ../applications/editors/emacs-modes/remember { };
|
2010-07-26 17:41:03 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rudel = callPackage ../applications/editors/emacs-modes/rudel { };
|
2008-08-21 12:58:51 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
scalaMode = callPackage ../applications/editors/emacs-modes/scala-mode { };
|
2010-08-02 20:01:55 +04:00
|
|
|
};
|
2008-08-21 12:58:51 +04:00
|
|
|
|
2010-08-02 20:01:55 +04:00
|
|
|
emacs22Packages = emacsPackages emacs22 pkgs.emacs22Packages;
|
2010-08-26 16:21:15 +04:00
|
|
|
emacs23Packages = recurseIntoAttrs (emacsPackages emacs23 pkgs.emacs23Packages);
|
2012-01-21 22:28:57 +04:00
|
|
|
emacs24Packages = recurseIntoAttrs (emacsPackages emacs24 pkgs.emacs24Packages);
|
2009-07-10 20:17:06 +04:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
epdfview = callPackage ../applications/misc/epdfview { };
|
2010-01-17 04:39:29 +03:00
|
|
|
|
2010-08-22 16:08:55 +04:00
|
|
|
espeak = callPackage ../applications/audio/espeak { };
|
|
|
|
|
2011-02-24 14:25:16 +03:00
|
|
|
esniper = callPackage ../applications/networking/esniper { };
|
|
|
|
|
2011-09-22 13:19:33 +04:00
|
|
|
etherape = callPackage ../applications/networking/sniffers/etherape {
|
|
|
|
inherit (gnome) gnomedocutils libgnome libglade gtk libgnomeui scrollkeeper;
|
|
|
|
};
|
|
|
|
|
2010-12-12 01:04:13 +03:00
|
|
|
evopedia = callPackage ../applications/misc/evopedia { };
|
|
|
|
|
2011-06-09 11:48:54 +04:00
|
|
|
keepassx = callPackage ../applications/misc/keepassx { };
|
|
|
|
|
2010-11-17 13:43:04 +03:00
|
|
|
# FIXME: Evince and other GNOME/GTK+ apps (e.g., Viking) provide
|
|
|
|
# `share/icons/hicolor/icon-theme.cache'. Arbitrarily give this one a
|
|
|
|
# higher priority.
|
|
|
|
evince = hiPrio (callPackage ../applications/misc/evince {
|
2008-07-27 14:24:08 +04:00
|
|
|
inherit (gnome) gnomedocutils gnomeicontheme libgnome
|
2009-11-05 00:44:01 +03:00
|
|
|
libgnomeui libglade glib gtk scrollkeeper gnome_keyring;
|
2010-11-17 13:43:04 +03:00
|
|
|
});
|
2008-07-27 14:24:08 +04:00
|
|
|
|
2011-03-14 13:25:26 +03:00
|
|
|
evolution_data_server = newScope (gnome // gtkLibs) ../servers/evolution-data-server { };
|
2010-09-06 03:37:54 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
exrdisplay = callPackage ../applications/graphics/exrdisplay {
|
2007-12-31 01:02:04 +03:00
|
|
|
fltk = fltk20;
|
|
|
|
};
|
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
fbpanel = callPackage ../applications/window-managers/fbpanel { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
|
|
|
fetchmail = import ../applications/misc/fetchmail {
|
2008-02-22 13:12:01 +03:00
|
|
|
inherit stdenv fetchurl openssl;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
fossil = callPackage ../applications/version-management/fossil { };
|
2010-05-12 17:17:19 +04:00
|
|
|
|
2012-02-06 01:02:27 +04:00
|
|
|
goldendict = callPackage ../applications/misc/goldendict { };
|
|
|
|
|
2010-06-03 19:19:59 +04:00
|
|
|
grass = import ../applications/misc/grass {
|
|
|
|
inherit (xlibs) libXmu libXext libXp libX11 libXt libSM libICE libXpm
|
|
|
|
libXaw libXrender;
|
|
|
|
inherit getConfig composableDerivation stdenv fetchurl
|
|
|
|
lib flex bison cairo fontconfig
|
|
|
|
gdal zlib ncurses gdbm proj pkgconfig swig
|
|
|
|
blas liblapack libjpeg libpng mysql unixODBC mesa postgresql python
|
|
|
|
readline sqlite tcl tk libtiff freetype ffmpeg makeWrapper wxGTK;
|
|
|
|
fftw = fftwSinglePrec;
|
|
|
|
motif = lesstif;
|
|
|
|
opendwg = libdwg;
|
|
|
|
wxPython = wxPython28;
|
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
grip = callPackage ../applications/misc/grip {
|
2009-09-20 21:01:31 +04:00
|
|
|
inherit (gnome) libgnome libgnomeui vte;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
wavesurfer = callPackage ../applications/misc/audio/wavesurfer { };
|
2008-09-24 04:42:06 +04:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
wireshark = callPackage ../applications/networking/sniffers/wireshark { };
|
2010-04-29 12:54:02 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
wvdial = callPackage ../os-specific/linux/wvdial { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2011-01-16 19:28:08 +03:00
|
|
|
fbida = callPackage ../applications/graphics/fbida { };
|
2009-08-04 11:14:43 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
fdupes = callPackage ../tools/misc/fdupes { };
|
2008-10-28 14:56:43 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
feh = callPackage ../applications/graphics/feh { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2011-08-19 16:13:48 +04:00
|
|
|
firefox = pkgs.firefoxPkgs.firefox;
|
2010-10-05 21:44:33 +04:00
|
|
|
|
2011-10-06 17:16:47 +04:00
|
|
|
firefoxWrapper = wrapFirefox { browser = pkgs.firefox; };
|
2008-07-18 14:41:27 +04:00
|
|
|
|
2012-02-14 17:47:27 +04:00
|
|
|
firefoxPkgs = pkgs.firefox100Pkgs;
|
2008-07-18 14:41:27 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
firefox36Pkgs = callPackage ../applications/networking/browsers/firefox/3.6.nix {
|
2009-05-05 19:46:24 +04:00
|
|
|
inherit (gtkLibs) gtk pango;
|
|
|
|
inherit (gnome) libIDL;
|
2010-01-22 01:23:59 +03:00
|
|
|
};
|
2009-05-05 19:46:24 +04:00
|
|
|
|
2011-10-06 17:16:47 +04:00
|
|
|
firefox36Wrapper = wrapFirefox { browser = firefox36Pkgs.firefox; };
|
2009-07-06 15:42:21 +04:00
|
|
|
|
2012-02-02 19:44:22 +04:00
|
|
|
firefox90Pkgs = callPackage ../applications/networking/browsers/firefox/9.0.nix {
|
2011-08-22 10:54:03 +04:00
|
|
|
inherit (gtkLibs) gtk pango;
|
|
|
|
inherit (gnome) libIDL;
|
|
|
|
};
|
|
|
|
|
2012-02-02 19:44:22 +04:00
|
|
|
firefox90Wrapper = wrapFirefox { browser = firefox90Pkgs.firefox; };
|
2011-08-23 14:35:53 +04:00
|
|
|
|
2012-02-02 19:44:22 +04:00
|
|
|
firefox100Pkgs = callPackage ../applications/networking/browsers/firefox/10.0.nix {
|
2011-09-30 19:44:22 +04:00
|
|
|
inherit (gtkLibs) gtk pango;
|
|
|
|
inherit (gnome) libIDL;
|
|
|
|
};
|
2010-01-26 17:53:03 +03:00
|
|
|
|
2012-02-02 19:44:22 +04:00
|
|
|
firefox100Wrapper = wrapFirefox { browser = firefox100Pkgs.firefox; };
|
2011-12-20 18:51:26 +04:00
|
|
|
|
2012-02-06 12:28:24 +04:00
|
|
|
firefox11Pkgs = callPackage ../applications/networking/browsers/firefox/11.0.nix {
|
|
|
|
inherit (gtkLibs) gtk pango;
|
|
|
|
inherit (gnome) libIDL;
|
|
|
|
};
|
|
|
|
|
2012-02-07 12:57:42 +04:00
|
|
|
firefox11Wrapper = lowPrio (wrapFirefox { browser = firefox11Pkgs.firefox; });
|
2011-12-20 18:51:26 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
flac = callPackage ../applications/audio/flac { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2011-12-03 19:16:17 +04:00
|
|
|
flashplayer = flashplayer11;
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2011-07-18 16:39:11 +04:00
|
|
|
flashplayer9 = callPackage ../applications/networking/browsers/mozilla-plugins/flashplayer-9 {
|
2011-07-18 18:44:28 +04:00
|
|
|
inherit (gtkLibs) atk;
|
2011-07-18 16:39:11 +04:00
|
|
|
};
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2011-07-18 16:39:11 +04:00
|
|
|
flashplayer10 = callPackage ../applications/networking/browsers/mozilla-plugins/flashplayer-10 {
|
|
|
|
inherit (gtkLibs) atk gdk_pixbuf;
|
|
|
|
debug = getConfig ["flashplayer" "debug"] false;
|
|
|
|
};
|
2008-10-16 17:36:27 +04:00
|
|
|
|
2011-12-03 19:16:17 +04:00
|
|
|
flashplayer11 = callPackage ../applications/networking/browsers/mozilla-plugins/flashplayer-11 {
|
|
|
|
inherit (gtkLibs) atk gdk_pixbuf;
|
|
|
|
debug = getConfig ["flashplayer" "debug"] false;
|
|
|
|
};
|
|
|
|
|
2011-03-04 12:48:24 +03:00
|
|
|
freecad = callPackage ../applications/graphics/freecad {
|
|
|
|
boost = boost146;
|
|
|
|
};
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
freemind = callPackage ../applications/misc/freemind {
|
2007-12-31 01:02:04 +03:00
|
|
|
jdk = jdk;
|
|
|
|
jre = jdk;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
freepv = callPackage ../applications/graphics/freepv { };
|
2009-04-09 00:05:59 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xfontsel = callPackage ../applications/misc/xfontsel { };
|
|
|
|
xlsfonts = callPackage ../applications/misc/xlsfonts { };
|
2009-12-24 17:48:36 +03:00
|
|
|
|
2011-09-07 03:32:01 +04:00
|
|
|
freerdp = callPackage ../applications/networking/remote/freerdp { };
|
|
|
|
|
2011-09-07 07:41:18 +04:00
|
|
|
freerdpUnstable = callPackage ../applications/networking/remote/freerdp/unstable.nix { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
fspot = callPackage ../applications/graphics/f-spot {
|
2007-12-31 01:02:04 +03:00
|
|
|
inherit (gnome) libgnome libgnomeui;
|
|
|
|
gtksharp = gtksharp1;
|
|
|
|
};
|
|
|
|
|
2011-08-30 04:14:16 +04:00
|
|
|
get_iplayer = callPackage ../applications/misc/get_iplayer {};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gimp = callPackage ../applications/graphics/gimp {
|
2009-11-05 00:28:11 +03:00
|
|
|
inherit (gnome) gtk libart_lgpl;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
2009-11-27 20:40:56 +03:00
|
|
|
|
2010-02-11 18:08:05 +03:00
|
|
|
gimpPlugins = recurseIntoAttrs (import ../applications/graphics/gimp/plugins {
|
|
|
|
inherit pkgs gimp;
|
|
|
|
});
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2009-01-21 01:15:42 +03:00
|
|
|
gitAndTools = recurseIntoAttrs (import ../applications/version-management/git-and-tools {
|
|
|
|
inherit pkgs;
|
|
|
|
});
|
|
|
|
git = gitAndTools.git;
|
2010-01-18 19:07:44 +03:00
|
|
|
gitFull = gitAndTools.gitFull;
|
2011-04-13 21:53:26 +04:00
|
|
|
gitSVN = gitAndTools.gitSVN;
|
2008-07-07 15:48:24 +04:00
|
|
|
|
2011-04-06 14:00:48 +04:00
|
|
|
giv = callPackage ../applications/graphics/giv {
|
2012-02-05 22:29:42 +04:00
|
|
|
inherit (gtkLibs) gdk_pixbuf gtk;
|
2011-04-06 19:18:14 +04:00
|
|
|
pcre = pcre.override { unicodeSupport = true; };
|
2011-04-06 14:00:48 +04:00
|
|
|
};
|
2008-07-07 15:48:24 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gnucash = callPackage ../applications/office/gnucash {
|
2011-07-10 17:34:56 +04:00
|
|
|
inherit (gnome) gtk glib libgnomeui libgtkhtml gtkhtml
|
|
|
|
libbonoboui libgnomeprint;
|
2009-09-30 17:11:17 +04:00
|
|
|
gconf = gnome.GConf;
|
2011-02-15 16:14:29 +03:00
|
|
|
guile = guile_1_8;
|
2011-07-09 16:11:41 +04:00
|
|
|
slibGuile = slibGuile.override { scheme = guile_1_8; };
|
2009-09-30 17:11:17 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
qcad = callPackage ../applications/misc/qcad { };
|
2009-03-28 05:25:03 +03:00
|
|
|
|
2011-12-04 02:21:00 +04:00
|
|
|
libquvi = callPackage ../applications/video/quvi/library.nix { };
|
|
|
|
|
|
|
|
quvi = callPackage ../applications/video/quvi/tool.nix { };
|
|
|
|
|
|
|
|
quvi_scripts = callPackage ../applications/video/quvi/scripts.nix { };
|
|
|
|
|
2010-10-11 23:59:22 +04:00
|
|
|
qjackctl = callPackage ../applications/audio/qjackctl { };
|
2008-08-18 20:03:21 +04:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
gkrellm = callPackage ../applications/misc/gkrellm { };
|
2008-02-13 19:38:33 +03:00
|
|
|
|
2011-03-11 01:20:35 +03:00
|
|
|
gmu = callPackage ../applications/audio/gmu { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gnash = callPackage ../applications/video/gnash {
|
2011-03-25 01:25:03 +03:00
|
|
|
xulrunner = icecatXulrunner3;
|
2010-08-23 18:52:48 +04:00
|
|
|
inherit (gnome) gtkglext;
|
|
|
|
inherit (gst_all) gstreamer gstPluginsBase gstPluginsGood gstFfmpeg;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gnome_mplayer = callPackage ../applications/video/gnome-mplayer {
|
2009-07-16 00:34:08 +04:00
|
|
|
inherit (gnome) GConf;
|
|
|
|
};
|
|
|
|
|
2011-12-04 17:49:03 +04:00
|
|
|
gnunet08 = callPackage ../applications/networking/p2p/gnunet/0.8.nix {
|
2008-08-24 22:48:09 +04:00
|
|
|
inherit (gnome) gtk libglade;
|
2011-06-27 00:09:44 +04:00
|
|
|
guile = guile_1_8;
|
2008-08-24 22:48:09 +04:00
|
|
|
gtkSupport = getConfig [ "gnunet" "gtkSupport" ] true;
|
|
|
|
};
|
|
|
|
|
2011-12-04 17:49:03 +04:00
|
|
|
gnunet = callPackage ../applications/networking/p2p/gnunet { };
|
2011-09-17 00:50:24 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gocr = callPackage ../applications/graphics/gocr { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2010-10-04 08:15:55 +04:00
|
|
|
gobby5 = callPackage ../applications/editors/gobby {
|
2010-10-04 08:15:23 +04:00
|
|
|
inherit (gtkLibs) gtkmm;
|
|
|
|
inherit (gnome) gtksourceview;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gphoto2 = callPackage ../applications/misc/gphoto2 { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2009-08-25 01:35:45 +04:00
|
|
|
gphoto2fs = builderDefsPackage ../applications/misc/gphoto2/gphotofs.nix {
|
2009-10-29 14:43:02 +03:00
|
|
|
inherit libgphoto2 fuse pkgconfig glib;
|
2009-08-25 01:35:45 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
graphicsmagick = callPackage ../applications/graphics/graphicsmagick { };
|
2010-03-04 17:44:47 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
graphicsmagick137 = callPackage ../applications/graphics/graphicsmagick/1.3.7.nix { };
|
2010-03-04 19:41:14 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gtkpod = callPackage ../applications/audio/gtkpod {
|
2009-04-13 19:41:10 +04:00
|
|
|
inherit (gnome) libglade;
|
|
|
|
};
|
|
|
|
|
2011-07-25 00:26:28 +04:00
|
|
|
jbidwatcher = callPackage ../applications/misc/jbidwatcher {
|
|
|
|
java = if stdenv.isLinux then jre else jdk;
|
|
|
|
};
|
2011-07-21 21:01:31 +04:00
|
|
|
|
2008-11-15 20:54:09 +03:00
|
|
|
qrdecode = builderDefsPackage (import ../tools/graphics/qrdecode) {
|
2012-01-27 21:55:41 +04:00
|
|
|
libpng = libpng12;
|
2011-08-05 20:13:20 +04:00
|
|
|
opencv = opencv_2_1;
|
2008-11-15 20:54:09 +03:00
|
|
|
};
|
|
|
|
|
2012-01-07 03:05:11 +04:00
|
|
|
qrencode = callPackage ../tools/graphics/qrencode { };
|
2008-11-15 20:54:09 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gecko_mediaplayer = callPackage ../applications/networking/browsers/mozilla-plugins/gecko-mediaplayer {
|
2009-07-16 00:34:08 +04:00
|
|
|
inherit (gnome) GConf;
|
2010-07-20 02:24:26 +04:00
|
|
|
browser = firefox;
|
2009-07-16 00:34:08 +04:00
|
|
|
};
|
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
geeqie = callPackage ../applications/graphics/geeqie { };
|
2009-11-25 11:58:42 +03:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
gqview = callPackage ../applications/graphics/gqview { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2012-02-23 22:32:42 +04:00
|
|
|
gmtk = callPackage ../applications/networking/browsers/mozilla-plugins/gmtk {
|
|
|
|
inherit (gnome) GConf;
|
|
|
|
inherit (gtkLibs) gtk;
|
|
|
|
};
|
|
|
|
|
2010-08-11 17:25:30 +04:00
|
|
|
googleearth = callPackage_i686 ../applications/misc/googleearth { };
|
2009-04-13 19:40:51 +04:00
|
|
|
|
2011-07-18 18:44:28 +04:00
|
|
|
google_talk_plugin = callPackage ../applications/networking/browsers/mozilla-plugins/google-talk-plugin {
|
|
|
|
inherit pkgsi686Linux;
|
|
|
|
};
|
|
|
|
|
2010-06-12 02:37:47 +04:00
|
|
|
gosmore = builderDefsPackage ../applications/misc/gosmore {
|
|
|
|
inherit fetchsvn curl pkgconfig libxml2;
|
|
|
|
inherit (gtkLibs) gtk;
|
2010-02-05 22:22:26 +03:00
|
|
|
};
|
2009-04-13 19:40:51 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gpsbabel = callPackage ../applications/misc/gpsbabel { };
|
2009-06-02 02:43:36 +04:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
gpscorrelate = callPackage ../applications/misc/gpscorrelate { };
|
2009-06-02 02:43:36 +04:00
|
|
|
|
2011-03-28 21:19:27 +04:00
|
|
|
gpsd = callPackage ../servers/gpsd { };
|
2009-05-31 15:29:42 +04:00
|
|
|
|
2010-11-02 15:23:01 +03:00
|
|
|
guitone = callPackage ../applications/version-management/guitone { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gv = callPackage ../applications/misc/gv { };
|
2008-06-19 02:48:34 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
hello = callPackage ../applications/misc/hello/ex-2 { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
homebank = callPackage ../applications/office/homebank { };
|
2010-01-27 01:22:11 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
htmldoc = callPackage ../applications/misc/htmldoc {
|
2012-01-03 14:02:33 +04:00
|
|
|
fltk = fltk13;
|
2010-06-02 01:15:40 +04:00
|
|
|
};
|
|
|
|
|
2012-02-10 14:13:39 +04:00
|
|
|
hugin = callPackage ../applications/graphics/hugin { };
|
2009-04-06 01:41:38 +04:00
|
|
|
|
2011-04-17 18:23:33 +04:00
|
|
|
hydrogen = callPackage ../applications/audio/hydrogen { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
i810switch = callPackage ../os-specific/linux/i810switch { };
|
2008-06-19 02:48:34 +04:00
|
|
|
|
2012-01-19 00:53:01 +04:00
|
|
|
icecat3 = lowPrio (callPackage ../applications/networking/browsers/icecat-3 {
|
2011-10-08 16:06:03 +04:00
|
|
|
inherit (gnome) libIDL libgnomeui gnome_vfs gtk pango;
|
2010-07-25 18:16:09 +04:00
|
|
|
inherit (xlibs) pixman;
|
2009-07-19 16:34:14 +04:00
|
|
|
inherit (pythonPackages) ply;
|
2008-07-28 19:55:11 +04:00
|
|
|
});
|
|
|
|
|
2012-01-19 00:53:01 +04:00
|
|
|
icecatXulrunner3 = lowPrio (callPackage ../applications/networking/browsers/icecat-3 {
|
2008-09-30 01:58:25 +04:00
|
|
|
application = "xulrunner";
|
2011-10-08 16:06:03 +04:00
|
|
|
inherit (gnome) libIDL libgnomeui gnome_vfs gtk pango;
|
2010-07-25 18:16:09 +04:00
|
|
|
inherit (xlibs) pixman;
|
2009-07-20 18:14:28 +04:00
|
|
|
inherit (pythonPackages) ply;
|
2008-09-30 01:58:25 +04:00
|
|
|
});
|
|
|
|
|
|
|
|
icecat3Xul =
|
2009-07-14 19:22:31 +04:00
|
|
|
(symlinkJoin "icecat-with-xulrunner-${icecat3.version}"
|
|
|
|
[ icecat3 icecatXulrunner3 ])
|
2008-12-12 12:38:31 +03:00
|
|
|
// { inherit (icecat3) gtk isFirefox3Like meta; };
|
2008-09-30 01:58:25 +04:00
|
|
|
|
2011-10-06 17:16:47 +04:00
|
|
|
icecat3Wrapper = wrapFirefox { browser = icecat3Xul; browserName = "icecat"; desktopName = "IceCat"; };
|
2011-04-12 12:12:00 +04:00
|
|
|
|
2012-01-27 22:56:31 +04:00
|
|
|
icewm = callPackage ../applications/window-managers/icewm { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2010-08-29 19:53:42 +04:00
|
|
|
id3v2 = callPackage ../applications/audio/id3v2 { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
ikiwiki = callPackage ../applications/misc/ikiwiki {
|
2009-11-03 18:57:22 +03:00
|
|
|
inherit (perlPackages) TextMarkdown URI HTMLParser HTMLScrubber
|
2010-04-29 13:35:20 +04:00
|
|
|
HTMLTemplate TimeDate CGISession DBFile CGIFormBuilder LocaleGettext
|
2012-02-07 18:01:05 +04:00
|
|
|
RpcXML XMLSimple PerlMagick YAML YAMLLibYAML;
|
2011-07-08 13:30:05 +04:00
|
|
|
gitSupport = false;
|
|
|
|
monotoneSupport = false;
|
2009-10-16 12:38:25 +04:00
|
|
|
extraUtils = [];
|
2009-10-15 01:00:54 +04:00
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
imagemagick = callPackage ../applications/graphics/ImageMagick {
|
2010-07-28 19:35:01 +04:00
|
|
|
tetex = null;
|
|
|
|
librsvg = null;
|
2008-05-16 15:26:23 +04:00
|
|
|
};
|
2007-12-31 01:02:04 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
imagemagickBig = callPackage ../applications/graphics/ImageMagick { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2009-03-19 19:40:28 +03:00
|
|
|
# Impressive, formerly known as "KeyJNote".
|
2010-08-03 01:40:34 +04:00
|
|
|
impressive = callPackage ../applications/office/impressive {
|
2009-03-19 19:40:28 +03:00
|
|
|
# XXX These are the PyOpenGL dependencies, which we need here.
|
2011-06-28 17:51:55 +04:00
|
|
|
inherit (pythonPackages) pyopengl;
|
|
|
|
};
|
2009-03-19 19:40:28 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
inkscape = callPackage ../applications/graphics/inkscape {
|
2009-10-18 08:43:40 +04:00
|
|
|
inherit (pythonPackages) lxml;
|
2008-02-03 16:18:37 +03:00
|
|
|
inherit (gtkLibs) gtk glib glibmm gtkmm;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
ion3 = callPackage ../applications/window-managers/ion-3 {
|
2008-03-17 12:41:28 +03:00
|
|
|
lua = lua5;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
iptraf = callPackage ../applications/networking/iptraf { };
|
2009-10-12 14:52:47 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
irssi = callPackage ../applications/networking/irc/irssi { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2012-02-24 03:47:26 +04:00
|
|
|
bip = callPackage ../applications/networking/irc/bip { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jackmeter = callPackage ../applications/audio/jackmeter { };
|
2009-09-21 13:58:33 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jedit = callPackage ../applications/editors/jedit { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
jigdo = callPackage ../applications/misc/jigdo { };
|
2009-09-10 20:57:31 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
joe = callPackage ../applications/editors/joe { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2011-08-23 00:26:11 +04:00
|
|
|
jbrout = callPackage ../applications/graphics/jbrout {
|
|
|
|
inherit (pythonPackages) lxml;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jwm = callPackage ../applications/window-managers/jwm { };
|
2008-03-25 12:50:54 +03:00
|
|
|
|
2012-01-26 17:12:36 +04:00
|
|
|
k3d = callPackage ../applications/graphics/k3d {};
|
|
|
|
|
2010-11-15 22:44:53 +03:00
|
|
|
keepnote = callPackage ../applications/office/keepnote {
|
|
|
|
pygtk = pyGtkGlade;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
kermit = callPackage ../tools/misc/kermit { };
|
2009-09-14 22:50:17 +04:00
|
|
|
|
2011-06-29 20:21:02 +04:00
|
|
|
kino = callPackage ../applications/video/kino {
|
|
|
|
inherit (gnome) libglade;
|
2008-01-13 18:21:21 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
lame = callPackage ../applications/audio/lame { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
larswm = callPackage ../applications/window-managers/larswm { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2011-04-23 04:22:40 +04:00
|
|
|
lash = callPackage ../applications/audio/lash {
|
|
|
|
inherit (gtkLibs) gtk;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ladspaH = callPackage ../applications/audio/ladspa-plugins/ladspah.nix { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
ladspaPlugins = callPackage ../applications/audio/ladspa-plugins {
|
2010-06-25 22:21:19 +04:00
|
|
|
fftw = fftwSinglePrec;
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
ldcpp = callPackage ../applications/networking/p2p/ldcpp {
|
2008-03-15 09:11:45 +03:00
|
|
|
inherit (gnome) libglade;
|
|
|
|
};
|
|
|
|
|
2012-01-04 01:14:14 +04:00
|
|
|
librecad = callPackage ../applications/misc/librecad { };
|
|
|
|
|
2012-01-26 03:04:34 +04:00
|
|
|
libreoffice = callPackage ../applications/office/openoffice/libreoffice.nix {
|
|
|
|
inherit (perlPackages) ArchiveZip CompressZlib;
|
2012-03-13 00:15:08 +04:00
|
|
|
inherit (gnome) GConf ORBit2 gnome_vfs;
|
|
|
|
inherit (gst_all) gstreamer gstPluginsBase;
|
2012-03-14 13:40:26 +04:00
|
|
|
fontsConf = makeFontsConf {
|
|
|
|
fontDirectories = [
|
|
|
|
freefont_ttf xorg.fontmiscmisc xorg.fontbhttf
|
|
|
|
];
|
|
|
|
};
|
2012-01-26 03:04:34 +04:00
|
|
|
};
|
|
|
|
|
2011-05-07 21:52:57 +04:00
|
|
|
lingot = callPackage ../applications/audio/lingot {
|
|
|
|
inherit (gnome) libglade;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
links = callPackage ../applications/networking/browsers/links { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2012-01-21 23:25:41 +04:00
|
|
|
ledger = callPackage ../applications/office/ledger/2.6.3.nix { };
|
2011-07-21 02:56:39 +04:00
|
|
|
ledger3 = callPackage ../applications/office/ledger/3.0.nix { };
|
2009-11-10 14:02:45 +03:00
|
|
|
|
2012-02-02 02:33:35 +04:00
|
|
|
links2 = callPackage ../applications/networking/browsers/links2 { };
|
2010-11-29 21:03:03 +03:00
|
|
|
|
2011-01-13 23:49:58 +03:00
|
|
|
linphone = callPackage ../applications/networking/linphone {
|
2012-02-10 14:13:48 +04:00
|
|
|
inherit (gnome) libglade;
|
2011-01-13 23:49:58 +03:00
|
|
|
};
|
|
|
|
|
2011-04-23 03:00:55 +04:00
|
|
|
lmms = callPackage ../applications/audio/lmms { };
|
|
|
|
|
2010-09-18 20:29:07 +04:00
|
|
|
lxdvdrip = callPackage ../applications/video/lxdvdrip { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
lynx = callPackage ../applications/networking/browsers/lynx { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
lyx = callPackage ../applications/misc/lyx {
|
2008-01-30 22:38:07 +03:00
|
|
|
qt = qt4;
|
|
|
|
};
|
|
|
|
|
2011-02-02 02:24:13 +03:00
|
|
|
makeself = callPackage ../applications/misc/makeself { };
|
|
|
|
|
2010-08-10 02:40:51 +04:00
|
|
|
matchbox = callPackage ../applications/window-managers/matchbox { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
meld = callPackage ../applications/version-management/meld {
|
2010-04-06 23:39:29 +04:00
|
|
|
inherit (gnome) scrollkeeper;
|
|
|
|
pygtk = pyGtkGlade;
|
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
mercurial = callPackage ../applications/version-management/mercurial {
|
2012-02-22 03:35:35 +04:00
|
|
|
inherit (pythonPackages) curses;
|
2012-01-21 23:08:58 +04:00
|
|
|
guiSupport = false; # use mercurialFull to get hgk GUI
|
2007-12-31 01:02:04 +03:00
|
|
|
};
|
|
|
|
|
2012-01-21 23:08:56 +04:00
|
|
|
mercurialFull = appendToName "full" (pkgs.mercurial.override { guiSupport = true; });
|
|
|
|
|
2011-05-08 13:35:37 +04:00
|
|
|
merkaartor = callPackage ../applications/misc/merkaartor { };
|
2010-06-13 23:32:04 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
meshlab = callPackage ../applications/graphics/meshlab {
|
2012-02-20 22:00:09 +04:00
|
|
|
qt = qt47;
|
2009-05-13 14:21:29 +04:00
|
|
|
};
|
|
|
|
|
2008-09-07 16:58:56 +04:00
|
|
|
midori = builderDefsPackage (import ../applications/networking/browsers/midori) {
|
2008-10-09 14:10:49 +04:00
|
|
|
inherit imagemagick intltool python pkgconfig webkit libxml2
|
2010-08-24 17:58:57 +04:00
|
|
|
which gettext makeWrapper file libidn sqlite docutils libnotify
|
|
|
|
vala dbus_glib;
|
2009-10-29 17:19:13 +03:00
|
|
|
inherit (gtkLibs) gtk glib;
|
2011-10-08 20:58:32 +04:00
|
|
|
inherit (gnome) gtksourceview;
|
2010-07-09 15:35:07 +04:00
|
|
|
inherit (webkit.passthru.args) libsoup;
|
2010-08-24 17:58:57 +04:00
|
|
|
inherit (xlibs) kbproto xproto libXScrnSaver scrnsaverproto;
|
2008-09-07 16:58:56 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
minicom = callPackage ../tools/misc/minicom { };
|
2008-04-11 13:32:27 +04:00
|
|
|
|
2011-04-25 00:10:43 +04:00
|
|
|
minidjvu = callPackage ../applications/graphics/minidjvu { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mmex = callPackage ../applications/office/mmex { };
|
2010-01-26 00:40:52 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
monodevelop = callPackage ../applications/editors/monodevelop {
|
2011-10-08 16:06:03 +04:00
|
|
|
inherit (gnome) gnome_vfs libbonobo libglade libgnome GConf glib gtk;
|
2007-12-31 01:02:04 +03:00
|
|
|
mozilla = firefox;
|
|
|
|
gtksharp = gtksharp2;
|
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
monodoc = callPackage ../applications/editors/monodoc {
|
2007-12-31 01:02:04 +03:00
|
|
|
gtksharp = gtksharp1;
|
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
monotone = callPackage ../applications/version-management/monotone {
|
2009-12-29 14:57:27 +03:00
|
|
|
lua = lua5;
|
|
|
|
};
|
|
|
|
|
|
|
|
monotoneViz = builderDefsPackage (import ../applications/version-management/monotone-viz/mtn-head.nix) {
|
2010-12-20 17:58:56 +03:00
|
|
|
inherit ocaml graphviz pkgconfig autoconf automake libtool;
|
|
|
|
inherit (ocamlPackages) lablgtk;
|
2009-12-29 14:57:27 +03:00
|
|
|
inherit (gnome) gtk libgnomecanvas glib;
|
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
mozilla = callPackage ../applications/networking/browsers/mozilla {
|
2007-12-31 01:02:04 +03:00
|
|
|
inherit (gnome) libIDL;
|
|
|
|
};
|
|
|
|
|
2009-02-08 20:23:22 +03:00
|
|
|
mozplugger = builderDefsPackage (import ../applications/networking/browsers/mozilla-plugins/mozplugger) {
|
2009-02-11 13:02:10 +03:00
|
|
|
inherit firefox;
|
2009-02-08 20:23:22 +03:00
|
|
|
inherit (xlibs) libX11 xproto;
|
|
|
|
};
|
|
|
|
|
2010-10-19 17:19:59 +04:00
|
|
|
mp3info = callPackage ../applications/audio/mp3info { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mpc123 = callPackage ../applications/audio/mpc123 { };
|
2010-01-29 01:34:27 +03:00
|
|
|
|
2010-08-21 20:54:02 +04:00
|
|
|
mpg123 = callPackage ../applications/audio/mpg123 { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mpg321 = callPackage ../applications/audio/mpg321 { };
|
2008-02-12 00:02:38 +03:00
|
|
|
|
2011-12-05 05:32:25 +04:00
|
|
|
ncmpcpp = callPackage ../applications/audio/ncmpcpp { };
|
|
|
|
|
2010-08-21 00:09:22 +04:00
|
|
|
MPlayer = callPackage ../applications/video/MPlayer { };
|
2007-12-31 01:02:04 +03:00
|
|
|
|
2008-10-30 16:00:50 +03:00
|
|
|
MPlayerPlugin = browser:
|
2008-07-28 19:55:11 +04:00
|
|
|
import ../applications/networking/browsers/mozilla-plugins/mplayerplug-in {
|
2008-10-30 16:00:50 +03:00
|
|
|
inherit browser;
|
2008-07-28 19:55:11 +04:00
|
|
|
inherit fetchurl stdenv pkgconfig gettext;
|
|
|
|
inherit (xlibs) libXpm;
|
|
|
|
# !!! should depend on MPlayer
|
|
|
|
};
|
2003-11-13 16:11:38 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mrxvt = callPackage ../applications/misc/mrxvt { };
|
2007-09-05 00:06:18 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
multisync = callPackage ../applications/misc/multisync {
|
2008-12-02 15:25:56 +03:00
|
|
|
inherit (gnome) gtk glib ORBit2 libbonobo libgnomeui GConf;
|
|
|
|
};
|
|
|
|
|
2011-02-10 22:23:27 +03:00
|
|
|
mumble = callPackage ../applications/networking/mumble {
|
|
|
|
avahi = avahi.override {
|
2011-09-20 00:20:17 +04:00
|
|
|
withLibdnssdCompat = true;
|
2011-02-10 22:23:27 +03:00
|
|
|
};
|
2011-05-10 11:07:35 +04:00
|
|
|
jackSupport = getConfig [ "mumble" "jackSupport" ] false;
|
2011-02-10 22:23:27 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mutt = callPackage ../applications/networking/mailreaders/mutt { };
|
2007-08-06 19:09:38 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
msmtp = callPackage ../applications/networking/msmtp { };
|
2007-09-03 16:10:57 +04:00
|
|
|
|
2010-08-10 00:59:38 +04:00
|
|
|
mupdf = callPackage ../applications/misc/mupdf {
|
|
|
|
};
|
|
|
|
|
2012-01-07 21:06:49 +04:00
|
|
|
mythtv = callPackage ../applications/video/mythtv { };
|
2004-12-11 02:16:23 +03:00
|
|
|
|
2012-03-09 22:21:10 +04:00
|
|
|
tvtime = callPackage ../applications/video/tvtime {
|
|
|
|
kernel = linux;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
nano = callPackage ../applications/editors/nano { };
|
2006-01-20 14:30:24 +03:00
|
|
|
|
2010-08-22 16:04:03 +04:00
|
|
|
navipowm = callPackage ../applications/misc/navipowm {
|
|
|
|
};
|
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
navit = callPackage ../applications/misc/navit { };
|
2010-08-22 15:33:57 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
nedit = callPackage ../applications/editors/nedit {
|
2009-08-25 10:36:05 +04:00
|
|
|
motif = lesstif;
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
};
|
2004-01-21 12:34:19 +03:00
|
|
|
|
2009-09-13 12:54:47 +04:00
|
|
|
netsurfBrowser = netsurf.browser;
|
2009-09-21 14:09:20 +04:00
|
|
|
netsurf = recurseIntoAttrs (import ../applications/networking/browsers/netsurf { inherit pkgs; });
|
2009-09-13 12:54:47 +04:00
|
|
|
|
2012-01-21 22:29:14 +04:00
|
|
|
notmuch = callPackage ../applications/networking/mailreaders/notmuch {
|
|
|
|
# use emacsPackages.notmuch if you want emacs support
|
|
|
|
emacs = null;
|
|
|
|
};
|
2011-02-13 04:34:49 +03:00
|
|
|
|
2011-03-30 19:00:53 +04:00
|
|
|
nova = callPackage ../applications/virtualization/nova { };
|
|
|
|
|
2011-06-09 19:06:21 +04:00
|
|
|
novaclient = callPackage ../applications/virtualization/nova/client.nix { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
nvi = callPackage ../applications/editors/nvi { };
|
2009-04-16 23:28:57 +04:00
|
|
|
|
2011-01-15 00:44:43 +03:00
|
|
|
ocrad = callPackage ../applications/graphics/ocrad { };
|
|
|
|
|
2011-01-23 19:40:25 +03:00
|
|
|
offrss = callPackage ../applications/networking/offrss { };
|
|
|
|
|
2011-06-28 13:45:09 +04:00
|
|
|
oneteam = callPackage ../applications/networking/instant-messengers/oneteam {};
|
|
|
|
|
2010-11-28 13:07:49 +03:00
|
|
|
openbox = callPackage ../applications/window-managers/openbox { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
openjump = callPackage ../applications/misc/openjump { };
|
2010-05-12 02:19:37 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
openoffice = callPackage ../applications/office/openoffice {
|
2009-04-20 16:49:35 +04:00
|
|
|
inherit (perlPackages) ArchiveZip CompressZlib;
|
2009-11-04 03:39:27 +03:00
|
|
|
inherit (gnome) GConf ORBit2;
|
2010-07-22 14:41:34 +04:00
|
|
|
neon = neon029;
|
2012-01-07 17:19:06 +04:00
|
|
|
libwpd = libwpd_08;
|
2012-02-25 19:54:57 +04:00
|
|
|
zip = zip.override { enableNLS = false; };
|
2003-11-11 19:13:13 +03:00
|
|
|
};
|
2007-07-19 14:32:09 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
go_oo = callPackage ../applications/office/openoffice/go-oo.nix {
|
2012-03-08 14:12:02 +04:00
|
|
|
inherit (perl510Packages) ArchiveZip CompressZlib;
|
2010-05-25 21:05:52 +04:00
|
|
|
inherit (gnome) GConf ORBit2;
|
2010-07-22 14:41:34 +04:00
|
|
|
neon = neon029;
|
2012-03-08 02:34:54 +04:00
|
|
|
libwpd = libwpd_08;
|
2012-03-08 02:41:33 +04:00
|
|
|
/* It uses Switch.pm, deprecated in perl 5.14 */
|
|
|
|
perl = perl510;
|
2012-02-25 19:54:57 +04:00
|
|
|
zip = zip.override { enableNLS = false; };
|
2010-05-25 21:05:52 +04:00
|
|
|
};
|
|
|
|
|
2012-01-26 23:01:38 +04:00
|
|
|
openscad = callPackage ../applications/graphics/openscad {};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
opera = callPackage ../applications/networking/browsers/opera {
|
2011-09-28 23:26:00 +04:00
|
|
|
inherit (pkgs.gtkLibs) gdk_pixbuf atk;
|
|
|
|
inherit (pkgs.kde4) kdelibs;
|
|
|
|
inherit (pkgs.gst_all) gstreamer gstPluginsBase;
|
2006-08-13 13:46:54 +04:00
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
pan = callPackage ../applications/networking/newsreaders/pan {
|
2006-09-15 19:28:53 +04:00
|
|
|
spellChecking = false;
|
2005-09-07 18:57:30 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
panotools = callPackage ../applications/graphics/panotools { };
|
2009-05-18 17:53:01 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
pavucontrol = callPackage ../applications/audio/pavucontrol {
|
2009-04-03 19:58:18 +04:00
|
|
|
inherit (gtkLibs) gtkmm;
|
|
|
|
inherit (gnome) libglademm;
|
|
|
|
};
|
|
|
|
|
2012-02-22 19:02:21 +04:00
|
|
|
paraview = callPackage ../applications/graphics/paraview { };
|
2012-02-21 16:57:23 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pdftk = callPackage ../tools/typesetting/pdftk { };
|
2010-06-02 12:21:49 +04:00
|
|
|
|
2011-08-09 16:35:55 +04:00
|
|
|
pidgin = callPackage ../applications/networking/instant-messengers/pidgin {
|
2008-09-06 14:30:55 +04:00
|
|
|
openssl = if (getConfig ["pidgin" "openssl"] true) then openssl else null;
|
|
|
|
gnutls = if (getConfig ["pidgin" "gnutls"] false) then gnutls else null;
|
2011-04-14 15:17:45 +04:00
|
|
|
libgcrypt = if (getConfig ["pidgin" "gnutls"] false) then libgcrypt else null;
|
2008-04-26 03:40:18 +04:00
|
|
|
GStreamer = gst_all.gstreamer;
|
|
|
|
inherit (gnome) startupnotification;
|
2009-12-27 19:49:08 +03:00
|
|
|
inherit (gst_all) gstPluginsBase;
|
2008-04-26 03:40:18 +04:00
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
pidginlatex = callPackage ../applications/networking/instant-messengers/pidgin-plugins/pidgin-latex {
|
2008-04-26 03:40:18 +04:00
|
|
|
imagemagick = imagemagickBig;
|
|
|
|
};
|
2009-03-10 15:01:22 +03:00
|
|
|
|
2008-08-15 02:04:30 +04:00
|
|
|
pidginlatexSF = builderDefsPackage
|
2008-06-19 02:48:34 +04:00
|
|
|
(import ../applications/networking/instant-messengers/pidgin-plugins/pidgin-latex/pidgin-latex-sf.nix)
|
2008-04-26 03:40:18 +04:00
|
|
|
{
|
|
|
|
inherit pkgconfig pidgin texLive imagemagick which;
|
|
|
|
inherit (gtkLibs) glib gtk;
|
|
|
|
};
|
|
|
|
|
2010-08-09 10:51:34 +04:00
|
|
|
pidginmsnpecan = callPackage ../applications/networking/instant-messengers/pidgin-plugins/msn-pecan { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pidginotr = callPackage ../applications/networking/instant-messengers/pidgin-plugins/otr { };
|
2008-04-26 03:40:18 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pidginsipe = callPackage ../applications/networking/instant-messengers/pidgin-plugins/sipe { };
|
2010-05-11 21:28:54 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pinfo = callPackage ../applications/misc/pinfo { };
|
2005-09-07 18:57:30 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
pinta = callPackage ../applications/graphics/pinta {
|
2010-06-16 02:25:38 +04:00
|
|
|
gtksharp = gtksharp2;
|
|
|
|
};
|
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
pqiv = callPackage ../applications/graphics/pqiv { };
|
2008-05-27 19:05:16 +04:00
|
|
|
|
2007-09-03 16:10:57 +04:00
|
|
|
# perhaps there are better apps for this task? It's how I had configured my preivous system.
|
|
|
|
# And I don't want to rewrite all rules
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
procmail = callPackage ../applications/misc/procmail { };
|
2007-09-03 16:10:57 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pstree = callPackage ../applications/misc/pstree { };
|
2007-09-03 16:10:57 +04:00
|
|
|
|
2011-04-08 00:54:33 +04:00
|
|
|
puredata = callPackage ../applications/audio/puredata {
|
|
|
|
inherit (gtkLibs) glib;
|
|
|
|
inherit (xlibs) libX11;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pythonmagick = callPackage ../applications/graphics/PythonMagick { };
|
2007-08-09 23:58:39 +04:00
|
|
|
|
2012-01-07 19:06:49 +04:00
|
|
|
qemu = callPackage ../applications/virtualization/qemu/0.15.nix { };
|
|
|
|
|
|
|
|
qemu_0_13 = callPackage ../applications/virtualization/qemu/0.13.nix { };
|
2007-12-31 11:49:41 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
qemuSVN = callPackage ../applications/virtualization/qemu/svn-6642.nix { };
|
2009-02-24 15:22:15 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
qemuImage = callPackage ../applications/virtualization/qemu/linux-img { };
|
2007-12-31 11:49:41 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
qtpfsgui = callPackage ../applications/graphics/qtpfsgui { };
|
2009-04-06 01:41:13 +04:00
|
|
|
|
2011-07-08 01:32:55 +04:00
|
|
|
qtractor = callPackage ../applications/audio/qtractor {
|
2011-04-24 18:32:55 +04:00
|
|
|
inherit (gtkLibs) gtk;
|
|
|
|
};
|
|
|
|
|
2011-07-08 01:32:55 +04:00
|
|
|
rakarrack = callPackage ../applications/audio/rakarrack {
|
2011-04-24 23:44:36 +04:00
|
|
|
inherit (xorg) libXpm libXft;
|
2012-01-03 14:02:33 +04:00
|
|
|
fltk = fltk13;
|
2011-04-24 23:44:36 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rapidsvn = callPackage ../applications/version-management/rapidsvn { };
|
2010-03-10 23:44:40 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ratpoison = callPackage ../applications/window-managers/ratpoison { };
|
2007-08-04 02:38:36 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
rawtherapee = callPackage ../applications/graphics/rawtherapee {
|
2010-01-17 20:49:35 +03:00
|
|
|
inherit (gtkLibs) gtk gtkmm;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rcs = callPackage ../applications/version-management/rcs { };
|
2005-03-11 13:46:20 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rdesktop = callPackage ../applications/networking/remote/rdesktop { };
|
2008-01-28 15:28:23 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
RealPlayer = callPackage ../applications/video/RealPlayer {
|
2011-07-18 18:44:28 +04:00
|
|
|
inherit (gtkLibs) glib pango atk gtk;
|
|
|
|
libstdcpp5 = gcc33.gcc;
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
};
|
2005-09-12 02:39:06 +04:00
|
|
|
|
2010-10-20 17:05:49 +04:00
|
|
|
recode = callPackage ../tools/text/recode { };
|
|
|
|
|
2011-06-26 21:57:28 +04:00
|
|
|
retroshare = callPackage ../applications/networking/p2p/retroshare {
|
|
|
|
qt = qt4;
|
2011-07-18 18:44:28 +04:00
|
|
|
inherit (gnome) gnome_keyring;
|
2011-06-26 21:57:28 +04:00
|
|
|
};
|
|
|
|
|
2010-08-02 21:59:19 +04:00
|
|
|
rsync = callPackage ../applications/networking/sync/rsync {
|
2010-08-06 16:46:18 +04:00
|
|
|
enableACLs = !(stdenv.isDarwin || stdenv.isSunOS);
|
2012-01-19 00:38:24 +04:00
|
|
|
enableCopyDevicesPatch = (getConfig ["rsync" "enableCopyDevicesPatch"] false);
|
2007-09-12 19:49:28 +04:00
|
|
|
};
|
2007-09-12 14:56:56 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rxvt = callPackage ../applications/misc/rxvt { };
|
2007-09-12 14:56:56 +04:00
|
|
|
|
2007-10-31 15:17:14 +03:00
|
|
|
# = urxvt
|
2010-08-03 01:40:34 +04:00
|
|
|
rxvt_unicode = callPackage ../applications/misc/rxvt_unicode {
|
2011-07-18 18:44:28 +04:00
|
|
|
perlSupport = false;
|
|
|
|
};
|
2007-10-31 15:17:14 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
sakura = callPackage ../applications/misc/sakura {
|
2010-02-21 14:36:49 +03:00
|
|
|
inherit (gnome) vte;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
sbagen = callPackage ../applications/misc/sbagen { };
|
2007-09-12 14:56:56 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
scribus = callPackage ../applications/office/scribus {
|
2009-10-18 08:44:01 +04:00
|
|
|
inherit (gnome) libart_lgpl;
|
2011-11-02 19:00:11 +04:00
|
|
|
qt = qt4;
|
2009-10-18 08:44:01 +04:00
|
|
|
};
|
|
|
|
|
2011-12-05 02:03:03 +04:00
|
|
|
seeks = callPackage ../tools/networking/p2p/seeks {
|
|
|
|
opencv = opencv_2_1;
|
|
|
|
};
|
2010-07-22 13:03:35 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
seg3d = callPackage ../applications/graphics/seg3d {
|
2011-07-18 18:44:28 +04:00
|
|
|
wxGTK = wxGTK28.override { unicode = false; };
|
2010-03-02 02:31:35 +03:00
|
|
|
};
|
|
|
|
|
2011-04-23 02:07:59 +04:00
|
|
|
seq24 = callPackage ../applications/audio/seq24 {
|
|
|
|
inherit (gtkLibs) gtkmm;
|
|
|
|
};
|
|
|
|
|
2011-01-16 14:41:19 +03:00
|
|
|
siproxd = callPackage ../applications/networking/siproxd { };
|
|
|
|
|
2012-02-02 02:09:35 +04:00
|
|
|
skype_linux = callPackage_i686 ../applications/networking/skype {
|
|
|
|
usePulseAudio = getConfig [ "pulseaudio" ] false; # disabled by default (the 100% cpu bug)
|
|
|
|
};
|
2007-09-05 12:25:23 +04:00
|
|
|
|
2012-02-24 21:53:19 +04:00
|
|
|
dropbox = callPackage ../applications/networking/dropbox { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
slim = callPackage ../applications/display-managers/slim { };
|
2007-02-26 01:25:25 +03:00
|
|
|
|
2009-10-28 17:06:56 +03:00
|
|
|
sndBase = builderDefsPackage (import ../applications/audio/snd) {
|
2008-08-19 09:54:09 +04:00
|
|
|
inherit fetchurl stdenv stringsWithDeps lib fftw;
|
2008-03-17 12:41:28 +03:00
|
|
|
inherit pkgconfig gmp gettext;
|
2008-06-16 20:33:11 +04:00
|
|
|
inherit (xlibs) libXpm libX11;
|
2008-03-17 12:41:28 +03:00
|
|
|
inherit (gtkLibs) gtk glib;
|
2007-11-03 07:15:13 +03:00
|
|
|
};
|
|
|
|
|
2008-11-05 00:24:10 +03:00
|
|
|
snd = sndBase.passthru.function {
|
2011-02-15 16:14:29 +03:00
|
|
|
inherit mesa libtool jackaudio alsaLib;
|
|
|
|
guile = guile_1_8;
|
2008-08-15 02:04:30 +04:00
|
|
|
};
|
2007-11-03 07:15:13 +03:00
|
|
|
|
2011-08-11 02:39:53 +04:00
|
|
|
sonic_visualiser = callPackage ../applications/audio/sonic-visualiser {
|
|
|
|
inherit (pkgs.vamp) vampSDK;
|
|
|
|
inherit (pkgs.xlibs) libX11;
|
|
|
|
fftw = pkgs.fftwSinglePrec;
|
2009-09-21 13:58:36 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
sox = callPackage ../applications/misc/audio/sox { };
|
2008-06-19 02:48:34 +04:00
|
|
|
|
2011-04-23 01:42:38 +04:00
|
|
|
specimen = callPackage ../applications/audio/specimen {
|
|
|
|
inherit (gnome) gtk libgnomecanvas;
|
|
|
|
};
|
|
|
|
|
2011-01-06 02:23:22 +03:00
|
|
|
spotify = callPackage ../applications/audio/spotify { };
|
|
|
|
|
2010-11-04 11:28:24 +03:00
|
|
|
stalonetray = callPackage ../applications/window-managers/stalonetray {};
|
|
|
|
|
2008-08-10 00:21:33 +04:00
|
|
|
stumpwm = builderDefsPackage (import ../applications/window-managers/stumpwm) {
|
2009-05-31 10:07:25 +04:00
|
|
|
inherit texinfo;
|
|
|
|
clisp = clisp_2_44_1;
|
2008-08-15 02:04:30 +04:00
|
|
|
};
|
2008-08-10 00:21:33 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
subversion = callPackage ../applications/version-management/subversion/default.nix {
|
2011-01-20 12:41:02 +03:00
|
|
|
neon = pkgs.neon029;
|
2011-04-13 21:53:01 +04:00
|
|
|
bdbSupport = true;
|
|
|
|
httpServer = false;
|
|
|
|
httpSupport = true;
|
|
|
|
sslSupport = true;
|
|
|
|
pythonBindings = false;
|
|
|
|
perlBindings = false;
|
|
|
|
javahlBindings = false;
|
2012-01-14 15:41:06 +04:00
|
|
|
saslSupport = false;
|
2011-04-13 21:53:01 +04:00
|
|
|
compressionSupport = true;
|
2010-07-30 16:10:24 +04:00
|
|
|
httpd = apacheHttpd;
|
2012-01-14 15:41:06 +04:00
|
|
|
sasl = cyrus_sasl;
|
2008-06-19 19:29:25 +04:00
|
|
|
};
|
|
|
|
|
2011-04-13 21:53:14 +04:00
|
|
|
subversionClient = lowPrio (appendToName "client" (subversion.override {
|
|
|
|
bdbSupport = false;
|
|
|
|
perlBindings = true;
|
|
|
|
pythonBindings = true;
|
|
|
|
}));
|
|
|
|
|
2011-08-11 20:33:41 +04:00
|
|
|
surf = callPackage ../applications/misc/surf {
|
|
|
|
inherit (gtkLibs) gtk glib;
|
2011-10-08 20:58:32 +04:00
|
|
|
libsoup = gnome.libsoup;
|
2011-08-11 20:33:41 +04:00
|
|
|
};
|
|
|
|
|
2009-04-20 16:49:35 +04:00
|
|
|
svk = perlPackages.SVK;
|
2008-05-30 22:15:25 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
sylpheed = callPackage ../applications/networking/mailreaders/sylpheed {
|
2006-09-15 19:28:53 +04:00
|
|
|
sslSupport = true;
|
|
|
|
gpgSupport = true;
|
2006-01-26 23:45:11 +03:00
|
|
|
};
|
|
|
|
|
2008-06-19 02:48:34 +04:00
|
|
|
# linux only by now
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
synergy = callPackage ../applications/misc/synergy { };
|
2007-11-11 11:16:23 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
tahoelafs = callPackage ../tools/networking/p2p/tahoe-lafs {
|
2009-06-29 01:03:00 +04:00
|
|
|
inherit (pythonPackages) twisted foolscap simplejson nevow zfec
|
2010-02-03 16:38:03 +03:00
|
|
|
pycryptopp pysqlite darcsver setuptoolsTrial setuptoolsDarcs
|
2011-04-04 18:38:53 +04:00
|
|
|
numpy pyasn1 mock;
|
2009-06-29 01:03:00 +04:00
|
|
|
};
|
|
|
|
|
2009-04-25 15:19:42 +04:00
|
|
|
tailor = builderDefsPackage (import ../applications/version-management/tailor) {
|
2008-09-24 12:50:32 +04:00
|
|
|
inherit makeWrapper python;
|
2008-08-15 02:04:30 +04:00
|
|
|
};
|
2008-05-07 11:23:20 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
tangogps = callPackage ../applications/misc/tangogps {
|
2009-06-03 17:52:38 +04:00
|
|
|
gconf = gnome.GConf;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
teamspeak_client = callPackage ../applications/networking/instant-messengers/teamspeak/client.nix { };
|
2007-12-14 04:50:19 +03:00
|
|
|
|
2011-03-29 12:34:12 +04:00
|
|
|
taskjuggler = callPackage ../applications/misc/taskjuggler {
|
2008-05-29 23:12:53 +04:00
|
|
|
# KDE support is not working yet.
|
2010-04-01 17:34:36 +04:00
|
|
|
inherit (kde3) kdelibs kdebase;
|
2011-08-24 23:33:42 +04:00
|
|
|
withKde = getConfig [ "taskJuggler" "kde" ] false;
|
2008-05-29 23:12:53 +04:00
|
|
|
};
|
|
|
|
|
2011-12-30 02:14:08 +04:00
|
|
|
taskwarrior = callPackage ../applications/misc/taskwarrior { };
|
|
|
|
|
2011-12-30 02:27:32 +04:00
|
|
|
taskwarrior_unstable = callPackage ../applications/misc/taskwarrior/unstable.nix { };
|
|
|
|
|
2011-04-24 22:04:07 +04:00
|
|
|
tesseract = callPackage ../applications/graphics/tesseract { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
thinkingRock = callPackage ../applications/misc/thinking-rock { };
|
2009-02-06 06:14:30 +03:00
|
|
|
|
2012-01-18 02:43:26 +04:00
|
|
|
thunderbird = callPackage ../applications/networking/mailreaders/thunderbird/9.x.nix {
|
2011-08-20 18:30:09 +04:00
|
|
|
inherit (gnome) libIDL;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
timidity = callPackage ../tools/misc/timidity { };
|
2007-09-23 18:47:11 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
tkcvs = callPackage ../applications/version-management/tkcvs { };
|
2009-06-19 13:02:48 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
tla = callPackage ../applications/version-management/arch { };
|
2008-02-17 16:44:30 +03:00
|
|
|
|
2011-11-19 21:12:00 +04:00
|
|
|
torchat = callPackage ../applications/networking/instant-messengers/torchat {
|
|
|
|
wrapPython = pythonPackages.wrapPython;
|
|
|
|
};
|
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
transmission = callPackage ../applications/networking/p2p/transmission { };
|
2010-03-28 04:06:30 +04:00
|
|
|
|
2011-08-14 09:03:54 +04:00
|
|
|
trayer = callPackage ../applications/window-managers/trayer {
|
|
|
|
inherit (gtkLibs) gdk_pixbuf;
|
|
|
|
};
|
|
|
|
|
2011-07-24 13:57:06 +04:00
|
|
|
tree = callPackage ../tools/system/tree { };
|
|
|
|
|
2011-05-04 12:55:30 +04:00
|
|
|
tribler = callPackage ../applications/networking/p2p/tribler { };
|
2011-05-03 21:12:31 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
twinkle = callPackage ../applications/networking/twinkle {
|
2009-09-20 21:01:19 +04:00
|
|
|
boost = boostFull;
|
2011-05-31 13:09:35 +04:00
|
|
|
ccrtp = ccrtp_1_8;
|
|
|
|
libzrtpcpp = libzrtpcpp_1_6;
|
2009-09-20 21:01:19 +04:00
|
|
|
};
|
|
|
|
|
2010-12-20 17:58:56 +03:00
|
|
|
unison = callPackage ../applications/networking/sync/unison {
|
|
|
|
inherit (ocamlPackages) lablgtk;
|
2011-01-03 21:43:16 +03:00
|
|
|
enableX11 = getConfig [ "unison" "enableX11" ] true;
|
2010-12-20 17:58:56 +03:00
|
|
|
};
|
2007-08-10 12:21:31 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
uucp = callPackage ../tools/misc/uucp { };
|
2008-04-11 13:32:27 +04:00
|
|
|
|
2011-11-09 01:07:57 +04:00
|
|
|
uwimap = callPackage ../tools/networking/uwimap { };
|
|
|
|
|
2009-06-19 12:05:21 +04:00
|
|
|
uzbl = builderDefsPackage (import ../applications/networking/browsers/uzbl) {
|
2012-03-08 20:49:08 +04:00
|
|
|
inherit pkgconfig webkit makeWrapper glib_networking;
|
2009-10-29 17:19:13 +03:00
|
|
|
inherit (gtkLibs) gtk glib;
|
2010-10-24 00:54:07 +04:00
|
|
|
inherit (xlibs) libX11 kbproto;
|
2012-03-08 20:49:08 +04:00
|
|
|
inherit (gnome) libsoup;
|
2009-09-22 07:51:04 +04:00
|
|
|
};
|
|
|
|
|
2012-01-07 21:06:49 +04:00
|
|
|
valknut = callPackage ../applications/networking/p2p/valknut { };
|
2006-02-25 00:42:57 +03:00
|
|
|
|
2010-12-27 21:30:52 +03:00
|
|
|
vdpauinfo = callPackage ../tools/X11/vdpauinfo { };
|
|
|
|
|
2010-08-08 02:44:25 +04:00
|
|
|
veracity = callPackage ../applications/version-management/veracity {};
|
|
|
|
|
2009-12-29 14:57:27 +03:00
|
|
|
viewMtn = builderDefsPackage (import ../applications/version-management/viewmtn/0.10.nix)
|
|
|
|
{
|
2010-10-04 13:49:09 +04:00
|
|
|
inherit monotone cheetahTemplate highlight ctags
|
2009-12-29 14:57:27 +03:00
|
|
|
makeWrapper graphviz which python;
|
2010-10-04 13:49:09 +04:00
|
|
|
flup = pythonPackages.flup;
|
2009-12-29 14:57:27 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
vim = callPackage ../applications/editors/vim { };
|
2005-11-08 02:02:17 +03:00
|
|
|
|
2010-07-28 16:52:54 +04:00
|
|
|
vimHugeX = vim_configurable;
|
2007-08-10 23:53:30 +04:00
|
|
|
|
2007-12-14 01:30:31 +03:00
|
|
|
vim_configurable = import ../applications/editors/vim/configurable.nix {
|
2010-10-03 13:18:14 +04:00
|
|
|
inherit (pkgs) fetchurl stdenv ncurses pkgconfig gettext composableDerivation lib
|
|
|
|
getConfig;
|
2010-08-21 23:27:31 +04:00
|
|
|
inherit (pkgs.xlibs) libX11 libXext libSM libXpm
|
2010-08-03 14:59:57 +04:00
|
|
|
libXt libXaw libXau libXmu libICE;
|
2010-08-21 23:27:31 +04:00
|
|
|
inherit (pkgs.gtkLibs) glib gtk;
|
2007-12-12 10:20:41 +03:00
|
|
|
features = "huge"; # one of tiny, small, normal, big or huge
|
|
|
|
# optional features by passing
|
2008-06-19 02:48:34 +04:00
|
|
|
# python
|
2007-12-12 10:20:41 +03:00
|
|
|
# TODO mzschemeinterp perlinterp
|
2010-08-21 23:27:31 +04:00
|
|
|
inherit (pkgs) python perl tcl ruby /*x11*/;
|
2007-12-12 10:20:41 +03:00
|
|
|
|
2010-08-21 23:27:31 +04:00
|
|
|
lua = pkgs.lua5;
|
2010-08-03 14:59:57 +04:00
|
|
|
|
2007-12-12 10:20:41 +03:00
|
|
|
# optional features by flags
|
|
|
|
flags = [ "X11" ]; # only flag "X11" by now
|
|
|
|
};
|
|
|
|
|
2011-01-14 01:30:32 +03:00
|
|
|
virtviewer = callPackage ../applications/virtualization/virt-viewer {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
virtualgl = callPackage ../tools/X11/virtualgl { };
|
2010-07-10 12:45:44 +04:00
|
|
|
|
2012-02-05 04:51:35 +04:00
|
|
|
bumblebee = callPackage ../tools/X11/bumblebee { };
|
|
|
|
|
2011-04-22 13:39:48 +04:00
|
|
|
vkeybd = callPackage ../applications/audio/vkeybd {
|
|
|
|
inherit (xlibs) libX11;
|
|
|
|
};
|
|
|
|
|
2012-03-06 18:35:37 +04:00
|
|
|
vlc = callPackage ../applications/video/vlc { };
|
2005-02-27 02:45:19 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
vnstat = callPackage ../applications/networking/vnstat { };
|
2009-10-12 15:08:52 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
vorbisTools = callPackage ../applications/audio/vorbis-tools { };
|
2008-02-12 01:39:54 +03:00
|
|
|
|
2011-09-01 17:41:42 +04:00
|
|
|
vue = callPackage ../applications/misc/vue {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
vwm = callPackage ../applications/window-managers/vwm { };
|
2009-04-23 01:33:24 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
w3m = callPackage ../applications/networking/browsers/w3m {
|
2006-09-15 19:28:53 +04:00
|
|
|
graphicsSupport = false;
|
2005-02-27 02:45:19 +03:00
|
|
|
};
|
|
|
|
|
2010-08-05 19:47:15 +04:00
|
|
|
weechat = callPackage ../applications/networking/irc/weechat { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
wings = callPackage ../applications/graphics/wings { };
|
2010-07-01 13:08:37 +04:00
|
|
|
|
2008-06-19 02:48:34 +04:00
|
|
|
# I'm keen on wmiimenu only >wmii-3.5 no longer has it...
|
2007-09-03 16:10:57 +04:00
|
|
|
wmiimenu = import ../applications/window-managers/wmii31 {
|
2008-06-09 01:41:07 +04:00
|
|
|
libixp = libixp_for_wmii;
|
2007-09-03 16:10:57 +04:00
|
|
|
inherit fetchurl /* fetchhg */ stdenv gawk;
|
|
|
|
inherit (xlibs) libX11;
|
|
|
|
};
|
|
|
|
|
|
|
|
wmiiSnap = import ../applications/window-managers/wmii {
|
|
|
|
libixp = libixp_for_wmii;
|
|
|
|
inherit fetchurl /* fetchhg */ stdenv gawk;
|
2008-06-09 01:41:07 +04:00
|
|
|
inherit (xlibs) libX11 xextproto libXt libXext;
|
|
|
|
includeUnpack = getConfig ["stdenv" "includeUnpack"] false;
|
2007-03-19 02:58:22 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
wordnet = callPackage ../applications/misc/wordnet { };
|
2008-02-13 17:26:01 +03:00
|
|
|
|
2011-10-06 17:16:47 +04:00
|
|
|
wrapFirefox =
|
2011-10-06 17:52:54 +04:00
|
|
|
{ browser, browserName ? "firefox", desktopName ? "Firefox", nameSuffix ? ""
|
|
|
|
, icon ? "${browser}/lib/${browser.name}/icons/mozicon128.png" }:
|
2011-10-06 17:16:47 +04:00
|
|
|
import ../applications/networking/browsers/firefox/wrapper.nix {
|
2011-10-06 17:52:54 +04:00
|
|
|
inherit stdenv makeWrapper makeDesktopItem browser browserName desktopName nameSuffix icon;
|
2011-10-06 17:16:47 +04:00
|
|
|
plugins =
|
|
|
|
let
|
|
|
|
enableAdobeFlash = getConfig [ browserName "enableAdobeFlash" ] true;
|
|
|
|
enableGnash = getConfig [ browserName "enableGnash" ] false;
|
|
|
|
in
|
|
|
|
assert !(enableGnash && enableAdobeFlash);
|
|
|
|
([ ]
|
|
|
|
++ lib.optional enableGnash gnash
|
|
|
|
++ lib.optional enableAdobeFlash flashplayer
|
|
|
|
# RealPlayer is disabled by default for legal reasons.
|
|
|
|
++ lib.optional (system != "i686-linux" && getConfig [browserName "enableRealPlayer"] false) RealPlayer
|
|
|
|
++ lib.optional (getConfig [browserName "enableDjvu"] false) (djview4)
|
|
|
|
++ lib.optional (getConfig [browserName "enableMPlayer"] false) (MPlayerPlugin browser)
|
|
|
|
++ lib.optional (getConfig [browserName "enableGeckoMediaPlayer"] false) gecko_mediaplayer
|
|
|
|
++ lib.optional (supportsJDK && getConfig [browserName "jre"] false && jrePlugin ? mozillaPlugin) jrePlugin
|
|
|
|
++ lib.optional (getConfig [browserName "enableGoogleTalkPlugin"] false) google_talk_plugin
|
|
|
|
);
|
2011-12-15 16:11:54 +04:00
|
|
|
libs =
|
2011-12-12 21:25:51 +04:00
|
|
|
if getConfig [ browserName "enableQuakeLive" ] false
|
|
|
|
then with xlibs; [ stdenv.gcc libX11 libXxf86dga libXxf86vm libXext libXt alsaLib zlib ]
|
|
|
|
else [ ];
|
2011-10-06 17:16:47 +04:00
|
|
|
};
|
2004-10-06 15:32:20 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
x11vnc = callPackage ../tools/X11/x11vnc { };
|
2008-02-22 06:06:12 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
x2vnc = callPackage ../tools/X11/x2vnc { };
|
2008-03-17 09:29:32 +03:00
|
|
|
|
2009-02-08 17:17:05 +03:00
|
|
|
xaos = builderDefsPackage (import ../applications/graphics/xaos) {
|
|
|
|
inherit (xlibs) libXt libX11 libXext xextproto xproto;
|
2012-03-06 13:28:08 +04:00
|
|
|
inherit gsl aalib zlib intltool gettext perl;
|
|
|
|
libpng = libpng12;
|
2009-02-08 17:17:05 +03:00
|
|
|
};
|
|
|
|
|
2012-01-06 22:13:11 +04:00
|
|
|
xara = callPackage ../applications/graphics/xara { };
|
2005-12-13 03:13:01 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xawtv = callPackage ../applications/video/xawtv { };
|
2005-12-22 13:49:43 +03:00
|
|
|
|
2011-03-21 21:10:20 +03:00
|
|
|
xbindkeys = callPackage ../tools/X11/xbindkeys { };
|
2011-03-21 01:16:32 +03:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
xchat = callPackage ../applications/networking/irc/xchat { };
|
2003-12-08 14:56:50 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xchm = callPackage ../applications/misc/xchm { };
|
2004-10-06 16:06:23 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xcompmgr = callPackage ../applications/window-managers/xcompmgr { };
|
2010-01-06 23:45:43 +03:00
|
|
|
|
2011-03-29 14:32:49 +04:00
|
|
|
xdaliclock = callPackage ../tools/misc/xdaliclock {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xdg_utils = callPackage ../tools/X11/xdg-utils { };
|
2010-03-25 22:48:06 +03:00
|
|
|
|
2011-04-20 00:51:40 +04:00
|
|
|
xdotool = callPackage ../tools/X11/xdotool { };
|
|
|
|
|
2011-03-28 22:12:32 +04:00
|
|
|
xen = callPackage ../applications/virtualization/xen { };
|
2008-10-04 19:24:08 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
xfig = callPackage ../applications/graphics/xfig {
|
2006-12-27 21:14:57 +03:00
|
|
|
stdenv = overrideGCC stdenv gcc34;
|
2006-12-08 04:17:21 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xineUI = callPackage ../applications/video/xine-ui { };
|
2004-12-06 10:36:56 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
xneur = callPackage ../applications/misc/xneur {
|
2008-03-20 12:52:40 +03:00
|
|
|
GStreamer=gst_all.gstreamer;
|
2011-05-24 19:00:56 +04:00
|
|
|
inherit (gtkLibs) glib gtk pango atk gdk_pixbuf;
|
2008-06-19 02:48:34 +04:00
|
|
|
};
|
2008-03-20 12:52:40 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
xneur_0_8 = callPackage ../applications/misc/xneur/0.8.nix {
|
2009-10-29 14:43:02 +03:00
|
|
|
GStreamer = gst_all.gstreamer;
|
2008-06-19 02:48:34 +04:00
|
|
|
};
|
2008-03-20 12:52:40 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
xournal = callPackage ../applications/graphics/xournal {
|
2009-08-03 01:47:10 +04:00
|
|
|
inherit (gtkLibs) gtk atk pango glib;
|
2009-09-23 00:16:38 +04:00
|
|
|
inherit (gnome) libgnomeprint libgnomeprintui
|
2009-08-03 01:47:10 +04:00
|
|
|
libgnomecanvas;
|
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
xpdf = callPackage ../applications/misc/xpdf {
|
2006-09-15 19:28:53 +04:00
|
|
|
motif = lesstif;
|
2007-10-03 16:16:48 +04:00
|
|
|
base14Fonts = "${ghostscript}/share/ghostscript/fonts";
|
2006-08-30 03:40:29 +04:00
|
|
|
};
|
|
|
|
|
2010-08-25 18:25:51 +04:00
|
|
|
libxpdf = callPackage ../applications/misc/xpdf/libxpdf.nix {
|
2010-08-26 13:45:10 +04:00
|
|
|
};
|
2010-08-25 18:25:51 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
xpra = callPackage ../tools/X11/xpra {
|
2008-03-17 16:45:50 +03:00
|
|
|
pyrex = pyrex095;
|
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
xscreensaver = callPackage ../applications/graphics/xscreensaver {
|
2007-11-26 16:24:56 +03:00
|
|
|
inherit (gnome) libglade;
|
2008-08-15 02:04:30 +04:00
|
|
|
};
|
2007-11-22 23:26:00 +03:00
|
|
|
|
2011-04-20 20:31:41 +04:00
|
|
|
xsynth_dssi = callPackage ../applications/audio/xsynth-dssi {
|
|
|
|
inherit (gtkLibs) gtk;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xterm = callPackage ../applications/misc/xterm { };
|
2004-02-13 17:42:28 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xtrace = callPackage ../tools/X11/xtrace { };
|
2009-12-17 14:58:05 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xlaunch = callPackage ../tools/X11/xlaunch { };
|
2007-12-31 11:49:41 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xmacro = callPackage ../tools/X11/xmacro { };
|
2007-08-10 22:54:44 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xmove = callPackage ../applications/misc/xmove { };
|
2007-12-31 11:49:41 +03:00
|
|
|
|
2011-01-30 19:11:36 +03:00
|
|
|
xnee = callPackage ../tools/X11/xnee {
|
|
|
|
# Work around "missing separator" error.
|
|
|
|
stdenv = overrideInStdenv stdenv [ gnumake381 ];
|
2008-08-15 02:04:30 +04:00
|
|
|
};
|
2008-08-14 13:25:26 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
xvidcap = callPackage ../applications/video/xvidcap {
|
2006-12-01 19:44:26 +03:00
|
|
|
inherit (gnome) scrollkeeper libglade;
|
|
|
|
};
|
|
|
|
|
2012-01-07 21:06:49 +04:00
|
|
|
yate = callPackage ../applications/misc/yate { };
|
2009-10-18 08:43:48 +04:00
|
|
|
|
2011-08-11 13:35:17 +04:00
|
|
|
qgis = callPackage ../applications/misc/qgis {};
|
2007-12-11 01:36:52 +03:00
|
|
|
|
2011-04-23 17:54:25 +04:00
|
|
|
yoshimi = callPackage ../applications/audio/yoshimi {
|
2012-01-03 14:02:33 +04:00
|
|
|
fltk = fltk13;
|
2010-06-03 04:51:23 +04:00
|
|
|
};
|
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
zathura = callPackage ../applications/misc/zathura { };
|
2005-12-03 03:04:13 +03:00
|
|
|
|
2012-01-03 14:32:56 +04:00
|
|
|
zynaddsubfx = callPackage ../applications/audio/zynaddsubfx { };
|
2011-04-08 02:24:56 +04:00
|
|
|
|
2004-04-01 20:02:53 +04:00
|
|
|
### GAMES
|
|
|
|
|
2011-10-23 01:04:29 +04:00
|
|
|
alienarena = callPackage ../games/alienarena { };
|
|
|
|
|
2012-02-20 03:32:43 +04:00
|
|
|
andyetitmoves = if stdenv.isLinux then callPackage ../games/andyetitmoves {} else null;
|
2012-02-20 01:36:54 +04:00
|
|
|
|
2010-08-29 13:43:46 +04:00
|
|
|
asc = callPackage ../games/asc {
|
|
|
|
lua = lua5;
|
|
|
|
libsigcxx = libsigcxx12;
|
|
|
|
};
|
|
|
|
|
2010-11-27 22:18:22 +03:00
|
|
|
atanks = callPackage ../games/atanks {};
|
|
|
|
|
2011-02-15 16:14:29 +03:00
|
|
|
ballAndPaddle = callPackage ../games/ball-and-paddle {
|
|
|
|
guile = guile_1_8;
|
|
|
|
};
|
2008-10-04 14:08:59 +04:00
|
|
|
|
2012-02-11 18:33:27 +04:00
|
|
|
bitsnbots = callPackage ../games/bitsnbots {
|
|
|
|
lua = lua5;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
blackshades = callPackage ../games/blackshades { };
|
2010-07-08 02:22:19 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
blackshadeselite = callPackage ../games/blackshadeselite { };
|
2010-07-08 22:06:01 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
bsdgames = callPackage ../games/bsdgames { };
|
2009-10-27 02:03:36 +03:00
|
|
|
|
2011-03-28 01:18:05 +04:00
|
|
|
btanks = callPackage ../games/btanks { };
|
|
|
|
|
2011-03-27 20:35:45 +04:00
|
|
|
bzflag = callPackage ../games/bzflag { };
|
|
|
|
|
2010-08-18 18:25:07 +04:00
|
|
|
castle_combat = callPackage ../games/castle-combat { };
|
2008-10-07 02:49:37 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
construoBase = callPackage ../games/construo {
|
2010-07-29 22:55:16 +04:00
|
|
|
mesa = null;
|
|
|
|
freeglut = null;
|
2007-12-03 07:48:44 +03:00
|
|
|
};
|
|
|
|
|
2010-07-29 12:21:21 +04:00
|
|
|
construo = construoBase.override {
|
2007-12-03 07:48:44 +03:00
|
|
|
inherit mesa freeglut;
|
2008-08-15 02:04:30 +04:00
|
|
|
};
|
2004-04-01 20:02:53 +04:00
|
|
|
|
2010-09-29 02:37:27 +04:00
|
|
|
crack_attack = callPackage ../games/crack-attack { };
|
|
|
|
|
2010-11-30 00:12:53 +03:00
|
|
|
crrcsim = callPackage ../games/crrcsim {};
|
|
|
|
|
2011-02-24 14:25:16 +03:00
|
|
|
dwarf_fortress = callPackage_i686 ../games/dwarf-fortress {
|
2010-11-24 23:05:43 +03:00
|
|
|
gnomegtk = pkgsi686Linux.gnome.gtk;
|
2010-10-30 10:00:44 +04:00
|
|
|
};
|
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
eduke32 = callPackage ../games/eduke32 { };
|
2009-05-14 17:48:45 +04:00
|
|
|
|
2010-08-24 23:36:42 +04:00
|
|
|
egoboo = callPackage ../games/egoboo { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
exult = callPackage ../games/exult {
|
2009-10-02 17:01:31 +04:00
|
|
|
stdenv = overrideGCC stdenv gcc42;
|
2012-01-27 15:57:20 +04:00
|
|
|
libpng = libpng12;
|
2006-08-09 03:39:03 +04:00
|
|
|
};
|
|
|
|
|
2009-07-10 16:44:34 +04:00
|
|
|
/*
|
2008-07-12 21:00:57 +04:00
|
|
|
exultSnapshot = lowPrio (import ../games/exult/snapshot.nix {
|
|
|
|
inherit fetchurl stdenv SDL SDL_mixer zlib libpng unzip
|
2008-08-25 17:25:07 +04:00
|
|
|
autoconf automake libtool flex bison;
|
2008-07-12 21:00:57 +04:00
|
|
|
});
|
2009-07-10 16:44:34 +04:00
|
|
|
*/
|
2008-07-12 21:00:57 +04:00
|
|
|
|
2011-04-09 22:57:00 +04:00
|
|
|
flightgear = callPackage ../games/flightgear {};
|
|
|
|
|
2011-08-20 18:30:16 +04:00
|
|
|
freeciv = callPackage ../games/freeciv { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
freedink = callPackage ../games/freedink { };
|
2010-05-02 13:27:51 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
fsg = callPackage ../games/fsg {
|
2010-09-09 20:48:13 +04:00
|
|
|
wxGTK = wxGTK28.override { unicode = false; };
|
2007-10-29 13:52:04 +03:00
|
|
|
};
|
2007-10-27 21:55:13 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gemrb = callPackage ../games/gemrb { };
|
|
|
|
|
2010-11-29 23:51:09 +03:00
|
|
|
gl117 = callPackage ../games/gl-117 {};
|
|
|
|
|
2011-04-22 14:26:45 +04:00
|
|
|
glestae = callPackage ../games/glestae {};
|
|
|
|
|
2011-04-19 20:02:29 +04:00
|
|
|
globulation2 = callPackage ../games/globulation {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gltron = callPackage ../games/gltron { };
|
2007-05-15 01:47:11 +04:00
|
|
|
|
2010-12-24 08:47:55 +03:00
|
|
|
gnuchess = callPackage ../games/gnuchess { };
|
2009-01-31 23:09:54 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gnugo = callPackage ../games/gnugo { };
|
2010-05-17 13:21:42 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
gparted = callPackage ../tools/misc/gparted {
|
2011-06-21 22:00:23 +04:00
|
|
|
parted = parted_2_3;
|
2009-09-10 20:57:21 +04:00
|
|
|
inherit (gtkLibs) gtk glib gtkmm;
|
|
|
|
inherit (gnome) gnomedocutils;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
hexen = callPackage ../games/hexen { };
|
2009-04-15 02:25:14 +04:00
|
|
|
|
2011-06-20 01:46:45 +04:00
|
|
|
icbm3d = callPackage ../games/icbm3d { };
|
|
|
|
|
2010-09-30 22:58:48 +04:00
|
|
|
instead = callPackage ../games/instead {
|
|
|
|
lua = lua5;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
kobodeluxe = callPackage ../games/kobodeluxe { };
|
2009-04-15 02:25:03 +04:00
|
|
|
|
2008-08-08 11:16:34 +04:00
|
|
|
lincity = builderDefsPackage (import ../games/lincity) {
|
2008-08-25 17:25:07 +04:00
|
|
|
inherit (xlibs) libX11 libXext xextproto
|
2008-08-08 11:16:34 +04:00
|
|
|
libICE libSM xproto;
|
|
|
|
inherit libpng zlib;
|
2008-08-15 02:04:30 +04:00
|
|
|
};
|
2008-08-08 11:16:34 +04:00
|
|
|
|
2011-03-20 21:24:39 +03:00
|
|
|
mars = callPackage ../games/mars { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
micropolis = callPackage ../games/micropolis { };
|
2008-08-07 00:39:01 +04:00
|
|
|
|
2011-04-28 01:57:27 +04:00
|
|
|
naev = callPackage ../games/naev { };
|
|
|
|
|
2011-03-28 00:35:08 +04:00
|
|
|
njam = callPackage ../games/njam { };
|
|
|
|
|
2012-01-30 02:44:49 +04:00
|
|
|
oilrush = callPackage ../games/oilrush { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
openttd = callPackage ../games/openttd {
|
2008-04-11 02:12:20 +04:00
|
|
|
zlib = zlibStatic;
|
|
|
|
};
|
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
pioneers = callPackage ../games/pioneers { };
|
2010-02-03 01:21:56 +03:00
|
|
|
|
2011-06-20 01:33:31 +04:00
|
|
|
pong3d = callPackage ../games/pong3d { };
|
|
|
|
|
2010-08-12 00:14:25 +04:00
|
|
|
prboom = callPackage ../games/prboom { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
quake3demo = callPackage ../games/quake3/wrapper {
|
2008-06-15 00:55:48 +04:00
|
|
|
name = "quake3-demo-${quake3game.name}";
|
2006-10-11 20:45:55 +04:00
|
|
|
description = "Demo of Quake 3 Arena, a classic first-person shooter";
|
2006-09-15 19:28:53 +04:00
|
|
|
game = quake3game;
|
|
|
|
paks = [quake3demodata];
|
2006-01-26 17:43:05 +03:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
quake3demodata = callPackage ../games/quake3/demo { };
|
2006-01-28 02:51:36 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
quake3game = callPackage ../games/quake3/game { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
2011-03-26 02:33:09 +03:00
|
|
|
racer = callPackage ../games/racer { };
|
|
|
|
|
2011-03-31 02:08:33 +04:00
|
|
|
rigsofrods = callPackage ../games/rigsofrods {
|
|
|
|
mygui = myguiSvn;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rogue = callPackage ../games/rogue { };
|
2007-01-09 00:19:15 +03:00
|
|
|
|
2010-12-26 16:14:15 +03:00
|
|
|
sauerbraten = callPackage ../games/sauerbraten {};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
scummvm = callPackage ../games/scummvm { };
|
2004-06-09 22:06:29 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
scorched3d = callPackage ../games/scorched3d {
|
2009-04-17 02:50:36 +04:00
|
|
|
};
|
|
|
|
|
2009-01-03 16:44:04 +03:00
|
|
|
sgtpuzzles = builderDefsPackage (import ../games/sgt-puzzles) {
|
2010-02-18 13:29:40 +03:00
|
|
|
inherit (gtkLibs) gtk;
|
2010-01-15 15:00:12 +03:00
|
|
|
inherit pkgconfig fetchsvn perl;
|
2009-01-03 16:44:04 +03:00
|
|
|
inherit (xlibs) libX11;
|
|
|
|
};
|
|
|
|
|
2011-03-26 10:22:24 +03:00
|
|
|
simutrans = callPackage ../games/simutrans { };
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
six = callPackage ../games/six {
|
2010-05-17 13:21:42 +04:00
|
|
|
inherit (kde3) arts kdelibs;
|
|
|
|
};
|
|
|
|
|
2011-01-28 11:13:52 +03:00
|
|
|
soi = callPackage ../games/soi {};
|
|
|
|
|
2008-01-22 20:56:53 +03:00
|
|
|
# You still can override by passing more arguments.
|
2012-01-08 01:59:16 +04:00
|
|
|
spaceOrbit = callPackage ../games/orbit { };
|
2008-01-22 20:56:53 +03:00
|
|
|
|
2010-11-17 20:03:09 +03:00
|
|
|
spring = callPackage ../games/spring { };
|
2010-11-13 10:47:04 +03:00
|
|
|
|
2012-03-08 19:32:20 +04:00
|
|
|
springLobby = callPackage ../games/spring/springlobby.nix { };
|
2010-11-13 10:47:04 +03:00
|
|
|
|
2010-11-28 16:16:47 +03:00
|
|
|
stardust = callPackage ../games/stardust {};
|
|
|
|
|
2012-02-11 00:24:13 +04:00
|
|
|
stuntrally = callPackage ../games/stuntrally { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
superTux = callPackage ../games/super-tux { };
|
2010-05-17 13:21:42 +04:00
|
|
|
|
2010-11-17 13:43:00 +03:00
|
|
|
superTuxKart = callPackage ../games/super-tux-kart {
|
|
|
|
/* With GNU Make 3.82, the build process is stuck in the `data'
|
|
|
|
directory, after displaying "Making all in tracks", and `pstree'
|
|
|
|
indicates that `make' doesn't launch any new process. */
|
|
|
|
stdenv = overrideInStdenv stdenv [ gnumake381 ];
|
|
|
|
};
|
2008-10-12 18:28:51 +04:00
|
|
|
|
2010-12-17 18:41:30 +03:00
|
|
|
tbe = callPackage ../games/the-butterfly-effect {};
|
|
|
|
|
2011-06-20 02:25:52 +04:00
|
|
|
teetertorture = callPackage ../games/teetertorture { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
teeworlds = callPackage ../games/teeworlds { };
|
2009-01-13 22:44:11 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
tennix = callPackage ../games/tennix { };
|
2010-02-01 22:55:03 +03:00
|
|
|
|
2010-12-22 12:52:32 +03:00
|
|
|
tpm = callPackage ../games/thePenguinMachine { };
|
2007-08-09 21:33:18 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
tremulous = callPackage ../games/tremulous { };
|
2010-06-25 19:09:53 +04:00
|
|
|
|
2011-04-04 09:01:53 +04:00
|
|
|
speed_dreams = callPackage ../games/speed-dreams {
|
|
|
|
# Torcs wants to make shared libraries linked with plib libraries (it provides static).
|
|
|
|
# i686 is the only platform I know than can do that linking without plib built with -fPIC
|
|
|
|
plib = plib.override { enablePIC = if stdenv.isi686 then false else true; };
|
|
|
|
};
|
|
|
|
|
2010-08-22 18:18:58 +04:00
|
|
|
torcs = callPackage ../games/torcs {
|
|
|
|
# Torcs wants to make shared libraries linked with plib libraries (it provides static).
|
|
|
|
# i686 is the only platform I know than can do that linking without plib built with -fPIC
|
|
|
|
plib = plib.override { enablePIC = if stdenv.isi686 then false else true; };
|
|
|
|
};
|
|
|
|
|
2011-03-30 22:45:11 +04:00
|
|
|
trigger = callPackage ../games/trigger { };
|
|
|
|
|
2010-08-29 04:45:29 +04:00
|
|
|
ufoai = callPackage ../games/ufoai {
|
|
|
|
inherit (gnome) gtksourceview gtkglext;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ultimatestunts = callPackage ../games/ultimatestunts { };
|
2009-12-24 01:28:50 +03:00
|
|
|
|
2010-12-28 17:56:08 +03:00
|
|
|
ultrastardx = callPackage ../games/ultrastardx {
|
|
|
|
lua = lua5;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
urbanterror = callPackage ../games/urbanterror { };
|
2010-02-03 03:46:43 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ut2004demo = callPackage ../games/ut2004demo { };
|
2004-06-09 21:59:46 +04:00
|
|
|
|
2011-03-28 20:08:21 +04:00
|
|
|
vdrift = callPackage ../games/vdrift { };
|
|
|
|
|
2011-06-20 01:07:35 +04:00
|
|
|
vectoroids = callPackage ../games/vectoroids { };
|
|
|
|
|
2011-03-28 20:08:21 +04:00
|
|
|
warmux = callPackage ../games/warmux { };
|
2011-02-17 01:19:59 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
warsow = callPackage ../games/warsow {
|
2010-02-10 02:12:47 +03:00
|
|
|
libjpeg = libjpeg62;
|
2010-01-28 01:22:35 +03:00
|
|
|
};
|
|
|
|
|
2010-12-13 00:48:29 +03:00
|
|
|
warzone2100 = callPackage ../games/warzone2100 { };
|
2010-05-03 20:07:01 +04:00
|
|
|
|
2012-02-19 21:39:37 +04:00
|
|
|
widelands = callPackage ../games/widelands {
|
|
|
|
libpng = libpng12;
|
|
|
|
};
|
2011-04-17 21:55:29 +04:00
|
|
|
|
2009-01-31 23:09:54 +03:00
|
|
|
xboard = builderDefsPackage (import ../games/xboard) {
|
2009-02-05 19:50:45 +03:00
|
|
|
inherit (xlibs) libX11 xproto libXt libXaw libSM
|
2009-12-10 09:55:12 +03:00
|
|
|
libICE libXmu libXext libXpm;
|
|
|
|
inherit gnuchess texinfo;
|
2009-01-31 23:09:54 +03:00
|
|
|
};
|
|
|
|
|
2011-05-28 19:36:56 +04:00
|
|
|
xconq = callPackage ../games/xconq {};
|
|
|
|
|
2011-08-03 12:43:52 +04:00
|
|
|
# TODO: the corresponding nix file is missing
|
|
|
|
# xracer = callPackage ../games/xracer { };
|
2011-08-02 18:26:47 +04:00
|
|
|
|
2011-11-06 17:54:03 +04:00
|
|
|
xonotic = callPackage ../games/xonotic { };
|
|
|
|
|
2009-01-12 01:05:19 +03:00
|
|
|
xsokoban = builderDefsPackage (import ../games/xsokoban) {
|
|
|
|
inherit (xlibs) libX11 xproto libXpm libXt;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
zdoom = callPackage ../games/zdoom { };
|
2009-02-23 01:06:34 +03:00
|
|
|
|
2011-03-28 20:08:29 +04:00
|
|
|
zod = callPackage ../games/zod { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
zoom = callPackage ../games/zoom { };
|
2006-09-12 03:06:26 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
keen4 = callPackage ../games/keen4 { };
|
2006-10-29 02:28:35 +04:00
|
|
|
|
2004-04-01 20:02:53 +04:00
|
|
|
|
2007-02-28 19:18:58 +03:00
|
|
|
### DESKTOP ENVIRONMENTS
|
|
|
|
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
enlightenment = callPackage ../desktops/enlightenment { };
|
2009-01-23 01:46:39 +03:00
|
|
|
|
2011-09-27 02:28:35 +04:00
|
|
|
# e17 = recurseIntoAttrs (
|
|
|
|
# let callPackage = newScope pkgs.e17; in
|
|
|
|
# import ../desktops/e17 { inherit callPackage pkgs; }
|
|
|
|
# );
|
|
|
|
|
2011-10-08 20:58:32 +04:00
|
|
|
gnome2 = (callPackage ../desktops/gnome-2 {
|
|
|
|
callPackage = pkgs.newScope pkgs.gnome2;
|
|
|
|
self = pkgs.gnome2;
|
|
|
|
} // pkgs.gtkLibs);
|
2007-02-28 19:18:58 +03:00
|
|
|
|
2011-10-09 21:23:54 +04:00
|
|
|
gnome3 = (import ../desktops/gnome-3 {
|
|
|
|
callPackage = pkgs.newScope pkgs.gnome3;
|
2012-02-08 01:03:20 +04:00
|
|
|
});
|
2011-10-09 21:23:54 +04:00
|
|
|
|
2011-10-08 20:58:32 +04:00
|
|
|
gnome = recurseIntoAttrs gnome2;
|
2009-09-30 09:29:08 +04:00
|
|
|
|
2010-04-03 14:59:26 +04:00
|
|
|
kde3 = recurseIntoAttrs {
|
2009-03-10 10:58:12 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
kdelibs = callPackage ../desktops/kde-3/kdelibs {
|
2009-11-30 02:27:35 +03:00
|
|
|
stdenv = overrideGCC stdenv gcc43;
|
2009-03-10 10:58:12 +03:00
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
arts = callPackage ../development/libraries/arts {
|
2012-01-07 21:06:49 +04:00
|
|
|
inherit (pkgs.kde3) kdelibs;
|
2010-04-01 17:34:36 +04:00
|
|
|
};
|
|
|
|
|
2010-10-18 16:18:07 +04:00
|
|
|
k3b = callPackage ../applications/misc/k3b/1.0.nix {
|
2010-04-01 17:34:36 +04:00
|
|
|
inherit (kde3) kdelibs;
|
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
kphone = callPackage ../applications/networking/kphone {
|
2010-04-01 17:34:36 +04:00
|
|
|
stdenv = overrideGCC stdenv gcc42; # I'm to lazy to clean up header files
|
|
|
|
};
|
|
|
|
|
2007-02-28 19:18:58 +03:00
|
|
|
};
|
2008-06-19 02:48:34 +04:00
|
|
|
|
2011-10-29 01:25:09 +04:00
|
|
|
kde4 = recurseIntoAttrs pkgs.kde47;
|
2010-03-16 15:13:40 +03:00
|
|
|
|
2011-08-26 17:49:23 +04:00
|
|
|
kde47 = kdePackagesFor pkgs.kde47 "4.7";
|
2010-03-16 15:13:40 +03:00
|
|
|
|
2012-01-07 03:03:43 +04:00
|
|
|
kde48 = kdePackagesFor pkgs.kde48 "4.8";
|
|
|
|
|
2011-08-26 17:49:23 +04:00
|
|
|
kdePackagesFor = self: version:
|
2011-08-27 19:19:19 +04:00
|
|
|
let callPackageOrig = callPackage; in
|
|
|
|
let
|
|
|
|
callPackage = newScope self;
|
|
|
|
kde4 = callPackageOrig (../desktops/kde- + version) {
|
|
|
|
inherit callPackage callPackageOrig;
|
|
|
|
};
|
|
|
|
in kde4 // {
|
|
|
|
inherit kde4;
|
|
|
|
|
|
|
|
recurseForRelease = true;
|
|
|
|
|
|
|
|
akunambol = callPackage ../applications/networking/sync/akunambol { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
amarok = callPackage ../applications/audio/amarok { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
bangarang = callPackage ../applications/video/bangarang { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2012-01-06 04:55:30 +04:00
|
|
|
basket = callPackage ../applications/office/basket { };
|
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
bluedevil = callPackage ../tools/bluetooth/bluedevil { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2012-02-13 23:34:42 +04:00
|
|
|
calligra = callPackage ../applications/office/calligra { };
|
|
|
|
|
2011-12-26 14:13:55 +04:00
|
|
|
digikam = callPackage ../applications/graphics/digikam {
|
|
|
|
boost = boost147;
|
|
|
|
};
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
k3b = callPackage ../applications/misc/k3b { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
kadu = callPackage ../applications/networking/instant-messengers/kadu { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
kbluetooth = callPackage ../tools/bluetooth/kbluetooth { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
kde_wacomtablet = callPackage ../applications/misc/kde-wacomtablet { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
kdenlive = callPackage ../applications/video/kdenlive { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
kdesvn = callPackage ../applications/version-management/kdesvn { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
kdevelop = callPackage ../applications/editors/kdevelop { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
kdevplatform = callPackage ../development/libraries/kdevplatform { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
kdiff3 = callPackage ../tools/text/kdiff3 { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-10-08 00:46:29 +04:00
|
|
|
kile = callPackage ../applications/editors/kile { };
|
2011-10-04 15:12:11 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
kmplayer = callPackage ../applications/video/kmplayer {
|
|
|
|
inherit (pkgs.gtkLibs) pango;
|
|
|
|
};
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-08-30 02:43:11 +04:00
|
|
|
kmymoney = callPackage ../applications/office/kmymoney { };
|
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
kipi_plugins = callPackage ../applications/graphics/kipi-plugins {
|
|
|
|
inherit (pkgs.gtkLibs) gdk_pixbuf;
|
|
|
|
};
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-11-22 08:38:14 +04:00
|
|
|
koffice = callPackage ../applications/office/koffice {
|
|
|
|
boost = boost147;
|
|
|
|
};
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
konq_plugins = callPackage ../applications/networking/browsers/konq-plugins { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
konversation = callPackage ../applications/networking/irc/konversation { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
krename = callPackage ../applications/misc/krename { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
krusader = callPackage ../applications/misc/krusader { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
ktorrent = callPackage ../applications/networking/p2p/ktorrent { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2012-01-07 21:06:57 +04:00
|
|
|
kuickshow = callPackage ../applications/graphics/kuickshow { };
|
|
|
|
|
2012-01-08 23:29:07 +04:00
|
|
|
libalkimia = callPackage ../development/libraries/libalkimia { };
|
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
libktorrent = callPackage ../development/libraries/libktorrent { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2012-01-03 20:15:22 +04:00
|
|
|
libkvkontakte = callPackage ../development/libraries/libkvkontakte { };
|
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
liblikeback = callPackage ../development/libraries/liblikeback { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2012-01-03 17:39:09 +04:00
|
|
|
networkmanagement = callPackage ../tools/networking/networkmanagement { };
|
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
partitionManager = callPackage ../tools/misc/partition-manager { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
polkit_kde_agent = callPackage ../tools/security/polkit-kde-agent { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2012-01-24 04:00:34 +04:00
|
|
|
psi = callPackage ../applications/networking/instant-messengers/psi {
|
|
|
|
inherit (gtkLibs) glib;
|
|
|
|
};
|
2011-08-27 19:19:19 +04:00
|
|
|
|
|
|
|
quassel = callPackage ../applications/networking/irc/quassel { };
|
|
|
|
|
|
|
|
quasselDaemon = appendToName "daemon" (self.quassel.override {
|
|
|
|
monolithic = false;
|
|
|
|
daemon = true;
|
|
|
|
});
|
2011-08-26 17:49:23 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
quasselClient = appendToName "client" (self.quassel.override {
|
|
|
|
monolithic = false;
|
|
|
|
client = true;
|
|
|
|
});
|
2011-08-26 17:49:23 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
rekonq = callPackage ../applications/networking/browsers/rekonq { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
rsibreak = callPackage ../applications/misc/rsibreak { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
semnotes = callPackage ../applications/misc/semnotes { };
|
2011-08-29 11:39:08 +04:00
|
|
|
|
2012-01-08 23:29:28 +04:00
|
|
|
skrooge = callPackage ../applications/office/skrooge { };
|
|
|
|
|
2012-03-14 13:52:21 +04:00
|
|
|
telepathy = callPackage ../applications/networking/instant-messengers/telepathy/kde {};
|
|
|
|
|
2011-08-27 19:19:19 +04:00
|
|
|
yakuake = callPackage ../applications/misc/yakuake { };
|
2012-01-08 23:29:28 +04:00
|
|
|
|
|
|
|
zanshin = callPackage ../applications/office/zanshin { };
|
2012-01-25 02:09:17 +04:00
|
|
|
|
|
|
|
kwooty = callPackage ../applications/networking/newsreaders/kwooty { };
|
2011-08-27 19:19:19 +04:00
|
|
|
};
|
2010-12-26 18:26:01 +03:00
|
|
|
|
2011-01-25 02:52:22 +03:00
|
|
|
redshift = callPackage ../applications/misc/redshift {
|
|
|
|
inherit (xorg) libX11 libXrandr libxcb randrproto libXxf86vm
|
|
|
|
xf86vidmodeproto;
|
|
|
|
};
|
2010-08-11 19:49:42 +04:00
|
|
|
|
2011-02-24 14:25:16 +03:00
|
|
|
oxygen_gtk = callPackage ../misc/themes/gtk2/oxygen-gtk {
|
2011-01-25 02:52:22 +03:00
|
|
|
inherit (gtkLibs) glib gtk;
|
|
|
|
};
|
2011-01-24 00:04:12 +03:00
|
|
|
|
2012-01-17 23:15:50 +04:00
|
|
|
xfce = xfce48;
|
2010-08-11 19:49:42 +04:00
|
|
|
|
2011-08-22 21:40:07 +04:00
|
|
|
xfce46 = recurseIntoAttrs
|
|
|
|
(let callPackage = newScope pkgs.xfce46; in
|
|
|
|
import ../desktops/xfce-4.6 { inherit callPackage pkgs; });
|
2010-05-17 20:16:39 +04:00
|
|
|
|
2011-08-23 02:51:23 +04:00
|
|
|
xfce48 = recurseIntoAttrs
|
|
|
|
(let callPackage = newScope pkgs.xfce48; in
|
|
|
|
import ../desktops/xfce-4.8 { inherit callPackage pkgs; });
|
2010-05-17 20:16:39 +04:00
|
|
|
|
2010-08-11 19:49:42 +04:00
|
|
|
|
2009-09-11 18:06:51 +04:00
|
|
|
### SCIENCE
|
2009-09-23 00:16:38 +04:00
|
|
|
|
2011-07-09 01:23:48 +04:00
|
|
|
xplanet = callPackage ../applications/science/astronomy/xplanet {
|
2009-09-11 18:06:51 +04:00
|
|
|
inherit (gtkLibs) pango;
|
|
|
|
};
|
2009-03-17 17:03:03 +03:00
|
|
|
|
2011-07-11 00:17:44 +04:00
|
|
|
gravit = callPackage ../applications/science/astronomy/gravit { };
|
|
|
|
|
|
|
|
stellarium = callPackage ../applications/science/astronomy/stellarium { };
|
2010-08-11 19:49:42 +04:00
|
|
|
|
2008-10-05 13:04:30 +04:00
|
|
|
### SCIENCE/GEOMETRY
|
2008-04-15 13:35:52 +04:00
|
|
|
|
2008-06-27 23:15:01 +04:00
|
|
|
drgeo = builderDefsPackage (import ../applications/science/geometry/drgeo) {
|
|
|
|
inherit (gnome) libglade gtk;
|
2011-02-15 16:23:34 +03:00
|
|
|
inherit libxml2 perl intltool libtool pkgconfig;
|
2011-02-15 16:14:29 +03:00
|
|
|
guile = guile_1_8;
|
2008-08-15 02:04:30 +04:00
|
|
|
};
|
2008-06-27 23:15:01 +04:00
|
|
|
|
2010-08-12 14:59:05 +04:00
|
|
|
tetgen = callPackage ../applications/science/geometry/tetgen { };
|
|
|
|
|
2009-04-17 17:48:22 +04:00
|
|
|
|
2008-10-05 13:04:30 +04:00
|
|
|
### SCIENCE/BIOLOGY
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
alliance = callPackage ../applications/science/electronics/alliance {
|
2009-02-08 19:28:31 +03:00
|
|
|
motif = lesstif;
|
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
arb = callPackage ../applications/science/biology/arb {
|
2008-10-06 19:11:36 +04:00
|
|
|
lesstif = lesstif93;
|
2009-11-10 20:16:06 +03:00
|
|
|
stdenv = overrideGCC stdenv gcc42;
|
2008-10-05 13:04:30 +04:00
|
|
|
};
|
2008-08-07 19:01:21 +04:00
|
|
|
|
2012-01-12 23:23:47 +04:00
|
|
|
archimedes = callPackage ../applications/science/electronics/archimedes { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
biolib = callPackage ../development/libraries/science/biology/biolib { };
|
2008-08-07 19:01:21 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
emboss = callPackage ../applications/science/biology/emboss { };
|
2008-06-05 21:15:27 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
mrbayes = callPackage ../applications/science/biology/mrbayes { };
|
2008-06-05 21:15:27 +04:00
|
|
|
|
2009-12-13 23:24:23 +03:00
|
|
|
ncbiCTools = builderDefsPackage ../development/libraries/ncbi {
|
|
|
|
inherit tcsh mesa lesstif;
|
2010-01-21 18:39:11 +03:00
|
|
|
inherit (xlibs) libX11 libXaw xproto libXt libSM libICE
|
2009-12-13 23:24:23 +03:00
|
|
|
libXmu libXext;
|
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ncbi_tools = callPackage ../applications/science/biology/ncbi-tools { };
|
2008-06-06 23:42:00 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
paml = callPackage ../applications/science/biology/paml { };
|
2008-06-06 12:23:49 +04:00
|
|
|
|
2008-10-05 16:55:00 +04:00
|
|
|
/* slr = import ../applications/science/biology/slr {
|
2008-10-05 13:04:30 +04:00
|
|
|
inherit fetchurl stdenv liblapack;
|
2008-10-05 16:55:00 +04:00
|
|
|
}; */
|
2008-10-05 13:04:30 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pal2nal = callPackage ../applications/science/biology/pal2nal { };
|
2008-09-19 17:39:17 +04:00
|
|
|
|
2009-04-17 17:48:22 +04:00
|
|
|
|
2008-10-05 13:04:30 +04:00
|
|
|
### SCIENCE/MATH
|
|
|
|
|
2012-02-23 15:33:26 +04:00
|
|
|
atlas = callPackage ../development/libraries/science/math/atlas {
|
|
|
|
# The build process measures CPU capabilities and optimizes the
|
|
|
|
# library to perform best on that particular machine. That is a
|
|
|
|
# great feature, but it's of limited use with pre-built binaries
|
|
|
|
# coming from a central build farm.
|
|
|
|
tolerateCpuTimingInaccuracy = true;
|
|
|
|
};
|
2008-10-05 13:04:30 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
blas = callPackage ../development/libraries/science/math/blas { };
|
2010-01-26 17:53:08 +03:00
|
|
|
|
2009-12-14 03:00:34 +03:00
|
|
|
content = builderDefsPackage ../applications/science/math/content {
|
|
|
|
inherit mesa lesstif;
|
2010-01-21 18:39:11 +03:00
|
|
|
inherit (xlibs) libX11 libXaw xproto libXt libSM libICE
|
2009-12-14 03:14:43 +03:00
|
|
|
libXmu libXext libXcursor;
|
2009-12-14 03:00:34 +03:00
|
|
|
};
|
|
|
|
|
2011-03-17 17:45:36 +03:00
|
|
|
jags = callPackage ../applications/science/math/jags { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
liblapack = callPackage ../development/libraries/science/math/liblapack { };
|
2008-10-05 13:04:30 +04:00
|
|
|
|
2009-04-17 17:48:22 +04:00
|
|
|
|
2008-06-04 19:10:05 +04:00
|
|
|
### SCIENCE/LOGIC
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
coq = callPackage ../applications/science/logic/coq {
|
2010-12-20 17:58:56 +03:00
|
|
|
inherit (ocamlPackages) findlib lablgtk;
|
2011-11-26 23:39:14 +04:00
|
|
|
camlp5 = ocamlPackages.camlp5_5_transitional;
|
2008-06-04 19:10:05 +04:00
|
|
|
};
|
2008-04-15 13:35:52 +04:00
|
|
|
|
2010-12-05 20:28:41 +03:00
|
|
|
cvc3 = callPackage ../applications/science/logic/cvc3 {};
|
|
|
|
|
2010-08-26 02:38:11 +04:00
|
|
|
eprover = callPackage ../applications/science/logic/eProver {
|
|
|
|
texLive = texLiveAggregationFun {
|
|
|
|
paths = [
|
|
|
|
texLive texLiveExtra
|
|
|
|
];
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2010-08-25 23:50:24 +04:00
|
|
|
hol = callPackage ../applications/science/logic/hol { };
|
2008-04-15 13:35:52 +04:00
|
|
|
|
2010-12-20 13:32:22 +03:00
|
|
|
hol_light = callPackage ../applications/science/logic/hol_light {
|
2011-05-21 15:18:35 +04:00
|
|
|
inherit (ocamlPackages) findlib;
|
|
|
|
camlp5 = ocamlPackages.camlp5_strict;
|
2010-12-20 13:32:22 +03:00
|
|
|
};
|
2010-02-15 14:00:02 +03:00
|
|
|
|
2009-12-11 20:00:52 +03:00
|
|
|
isabelle = import ../applications/science/logic/isabelle {
|
2010-08-02 20:01:55 +04:00
|
|
|
inherit (pkgs) stdenv fetchurl nettools perl polyml;
|
|
|
|
inherit (pkgs.emacs23Packages) proofgeneral;
|
2009-12-11 20:00:52 +03:00
|
|
|
};
|
|
|
|
|
2010-12-04 21:39:44 +03:00
|
|
|
iprover = callPackage ../applications/science/logic/iprover {};
|
|
|
|
|
2010-12-02 00:29:42 +03:00
|
|
|
leo2 = callPackage ../applications/science/logic/leo2 {};
|
|
|
|
|
2010-12-31 20:48:55 +03:00
|
|
|
matita = callPackage ../applications/science/logic/matita {
|
2011-02-24 14:25:16 +03:00
|
|
|
inherit (ocamlPackages) findlib lablgtk ocaml_expat gmetadom ocaml_http
|
2010-12-31 20:48:55 +03:00
|
|
|
lablgtkmathview ocaml_mysql ocaml_sqlite3 ocamlnet ulex08 camlzip ocaml_pcre;
|
|
|
|
};
|
|
|
|
|
2010-12-05 22:54:27 +03:00
|
|
|
minisat = callPackage ../applications/science/logic/minisat {};
|
|
|
|
|
2010-12-13 00:48:29 +03:00
|
|
|
opensmt = callPackage ../applications/science/logic/opensmt { };
|
2010-12-05 21:22:14 +03:00
|
|
|
|
2011-11-24 23:53:42 +04:00
|
|
|
picosat = callPackage ../applications/science/logic/picosat {};
|
|
|
|
|
2010-08-26 15:37:05 +04:00
|
|
|
prover9 = callPackage ../applications/science/logic/prover9 { };
|
|
|
|
|
2010-12-03 14:26:34 +03:00
|
|
|
satallax = callPackage ../applications/science/logic/satallax {};
|
|
|
|
|
2010-12-04 14:43:01 +03:00
|
|
|
spass = callPackage ../applications/science/logic/spass {};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
ssreflect = callPackage ../applications/science/logic/ssreflect {
|
2011-11-26 23:39:14 +04:00
|
|
|
camlp5 = ocamlPackages.camlp5_5_transitional;
|
2009-11-05 18:08:12 +03:00
|
|
|
};
|
|
|
|
|
2011-06-15 14:35:18 +04:00
|
|
|
tptp = callPackage ../applications/science/logic/tptp {};
|
|
|
|
|
2008-08-22 00:43:53 +04:00
|
|
|
### SCIENCE / ELECTRONICS
|
|
|
|
|
2012-02-17 18:34:42 +04:00
|
|
|
caneda = callPackage ../applications/science/electronics/caneda { };
|
2010-10-24 21:01:09 +04:00
|
|
|
|
2010-10-24 21:00:57 +04:00
|
|
|
gtkwave = callPackage ../applications/science/electronics/gtkwave { };
|
|
|
|
|
2010-08-29 15:09:23 +04:00
|
|
|
kicad = callPackage ../applications/science/electronics/kicad { };
|
2010-08-22 16:09:47 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ngspice = callPackage ../applications/science/electronics/ngspice { };
|
2008-08-22 00:43:53 +04:00
|
|
|
|
2011-09-21 02:49:13 +04:00
|
|
|
qucs = callPackage ../applications/science/electronics/qucs { };
|
2009-04-17 17:48:22 +04:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
xoscope = callPackage ../applications/science/electronics/xoscope { };
|
2009-04-17 17:48:22 +04:00
|
|
|
|
2010-06-13 14:01:16 +04:00
|
|
|
|
2008-09-05 21:12:04 +04:00
|
|
|
### SCIENCE / MATH
|
|
|
|
|
2011-04-23 16:25:51 +04:00
|
|
|
ecm = callPackage ../applications/science/math/ecm { };
|
|
|
|
|
2011-07-08 01:53:21 +04:00
|
|
|
eukleides = callPackage ../applications/science/math/eukleides { };
|
|
|
|
|
2012-03-08 22:23:47 +04:00
|
|
|
gap = callPackage ../applications/science/math/gap { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
maxima = callPackage ../applications/science/math/maxima { };
|
2008-09-05 21:21:45 +04:00
|
|
|
|
2012-03-14 01:56:24 +04:00
|
|
|
wxmaxima = callPackage ../applications/science/math/wxmaxima { };
|
2009-10-29 14:57:58 +03:00
|
|
|
|
2010-12-05 22:11:21 +03:00
|
|
|
pari = callPackage ../applications/science/math/pari {};
|
|
|
|
|
2010-12-05 21:36:07 +03:00
|
|
|
singular = callPackage ../applications/science/math/singular {};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
scilab = callPackage ../applications/science/math/scilab {
|
2008-09-05 21:12:04 +04:00
|
|
|
withXaw3d = false;
|
|
|
|
withTk = true;
|
|
|
|
withGtk = false;
|
|
|
|
withOCaml = true;
|
|
|
|
withX = true;
|
|
|
|
};
|
|
|
|
|
2011-04-21 16:48:07 +04:00
|
|
|
msieve = callPackage ../applications/science/math/msieve { };
|
|
|
|
|
2010-08-10 01:58:21 +04:00
|
|
|
yacas = callPackage ../applications/science/math/yacas { };
|
|
|
|
|
2010-06-14 22:30:35 +04:00
|
|
|
### SCIENCE / MISC
|
|
|
|
|
2011-10-07 00:25:05 +04:00
|
|
|
boinc = callPackage ../applications/science/misc/boinc { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
golly = callPackage ../applications/science/misc/golly { };
|
2010-06-23 11:41:17 +04:00
|
|
|
|
2010-08-03 12:14:13 +04:00
|
|
|
simgrid = callPackage ../applications/science/misc/simgrid { };
|
2010-06-17 21:06:40 +04:00
|
|
|
|
2012-01-02 22:36:04 +04:00
|
|
|
tulip = callPackage ../applications/science/misc/tulip { };
|
2009-04-17 17:48:22 +04:00
|
|
|
|
2012-01-07 21:06:49 +04:00
|
|
|
vite = callPackage ../applications/science/misc/vite { };
|
2009-04-17 17:48:22 +04:00
|
|
|
|
2004-02-13 17:42:28 +03:00
|
|
|
### MISC
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
atari800 = callPackage ../misc/emulators/atari800 { };
|
2004-11-04 00:28:03 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
ataripp = callPackage ../misc/emulators/atari++ { };
|
2008-06-19 02:48:34 +04:00
|
|
|
|
2012-02-04 13:31:07 +04:00
|
|
|
auctex = callPackage ../tools/typesetting/tex/auctex { };
|
2004-11-04 00:28:03 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
busybox = callPackage ../misc/busybox {
|
2010-03-10 01:44:45 +03:00
|
|
|
enableStatic = true;
|
2006-09-15 19:28:53 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cups = callPackage ../misc/cups { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
2010-12-14 16:30:17 +03:00
|
|
|
cups_pdf_filter = callPackage ../misc/cups/pdf-filter.nix { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gutenprint = callPackage ../misc/drivers/gutenprint { };
|
2009-08-28 03:32:13 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gutenprintBin = callPackage ../misc/drivers/gutenprint/bin.nix { };
|
2009-08-28 03:32:13 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
cupsBjnp = callPackage ../misc/cups/drivers/cups-bjnp { };
|
2009-08-28 03:32:10 +04:00
|
|
|
|
2011-03-26 01:15:48 +03:00
|
|
|
darcnes = callPackage ../misc/emulators/darcnes { };
|
|
|
|
|
2012-02-04 13:31:07 +04:00
|
|
|
dblatex = callPackage ../tools/typesetting/tex/dblatex { };
|
2007-11-01 17:37:23 +03:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dosbox = callPackage ../misc/emulators/dosbox { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
dpkg = callPackage ../tools/package-management/dpkg { };
|
2008-06-08 07:56:32 +04:00
|
|
|
|
2010-11-28 12:21:36 +03:00
|
|
|
ekiga = newScope (pkgs.gtkLibs // pkgs.gnome) ../applications/networking/ekiga { };
|
2010-09-06 03:37:54 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
electricsheep = callPackage ../misc/screensavers/electricsheep { };
|
2009-04-30 21:41:19 +04:00
|
|
|
|
2011-03-26 01:15:48 +03:00
|
|
|
fakenes = callPackage ../misc/emulators/fakenes { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
foldingathome = callPackage ../misc/foldingathome { };
|
2009-04-18 00:36:54 +04:00
|
|
|
|
2011-01-28 11:44:31 +03:00
|
|
|
foo2zjs = callPackage ../misc/drivers/foo2zjs {};
|
2011-02-24 14:25:16 +03:00
|
|
|
|
2011-01-28 11:44:31 +03:00
|
|
|
foomatic_filters = callPackage ../misc/drivers/foomatic-filters {};
|
2009-04-18 00:36:54 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
freestyle = callPackage ../misc/freestyle {
|
2008-06-08 07:56:32 +04:00
|
|
|
#stdenv = overrideGCC stdenv gcc41;
|
|
|
|
};
|
|
|
|
|
2009-04-12 23:34:20 +04:00
|
|
|
gajim = builderDefsPackage (import ../applications/networking/instant-messengers/gajim) {
|
|
|
|
inherit perl intltool pyGtkGlade gettext pkgconfig makeWrapper pygobject
|
2009-04-17 17:48:22 +04:00
|
|
|
pyopenssl gtkspell libsexy pycrypto aspell pythonDBus pythonSexy
|
2009-04-12 23:34:20 +04:00
|
|
|
docutils;
|
|
|
|
dbus = dbus.libs;
|
|
|
|
inherit (gnome) gtk libglade;
|
2009-04-17 17:48:22 +04:00
|
|
|
inherit (xlibs) libXScrnSaver libXt xproto libXext xextproto libX11
|
2009-04-12 23:34:20 +04:00
|
|
|
scrnsaverproto;
|
|
|
|
python = pythonFull;
|
|
|
|
};
|
|
|
|
|
2010-08-24 13:57:57 +04:00
|
|
|
gensgs = callPackage_i686 ../misc/emulators/gens-gs { };
|
2010-08-24 00:28:14 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
ghostscript = callPackage ../misc/ghostscript {
|
2006-09-15 19:28:53 +04:00
|
|
|
x11Support = false;
|
2011-08-24 23:33:42 +04:00
|
|
|
cupsSupport = getConfig [ "ghostscript" "cups" ] true;
|
2012-03-09 21:15:11 +04:00
|
|
|
gnuFork = getConfig [ "ghostscript" "gnu" ] false;
|
2005-12-03 05:32:02 +03:00
|
|
|
};
|
|
|
|
|
2010-09-17 18:46:55 +04:00
|
|
|
ghostscriptX = appendToName "with-X" (ghostscript.override {
|
2007-08-14 18:09:58 +04:00
|
|
|
x11Support = true;
|
2010-09-17 18:46:55 +04:00
|
|
|
});
|
2007-09-03 16:10:57 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
gxemul = callPackage ../misc/gxemul { };
|
2007-10-04 02:38:09 +04:00
|
|
|
|
2012-01-07 21:06:49 +04:00
|
|
|
hplip = callPackage ../misc/drivers/hplip { };
|
2007-10-04 02:38:09 +04:00
|
|
|
|
2007-10-06 22:17:47 +04:00
|
|
|
# using the new configuration style proposal which is unstable
|
2011-05-10 00:49:51 +04:00
|
|
|
jack1d = callPackage ../misc/jackaudio/jack1.nix { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
jackaudio = callPackage ../misc/jackaudio { };
|
2008-06-19 02:48:34 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
keynav = callPackage ../tools/X11/keynav { };
|
2007-08-04 19:12:14 +04:00
|
|
|
|
2012-02-04 13:31:07 +04:00
|
|
|
lazylist = callPackage ../tools/typesetting/tex/lazylist { };
|
2006-01-27 23:51:41 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
lilypond = callPackage ../misc/lilypond {
|
2009-09-10 20:57:56 +04:00
|
|
|
inherit (gtkLibs) pango;
|
2011-02-17 11:23:56 +03:00
|
|
|
guile = guile_1_8;
|
2009-09-10 20:57:56 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
martyr = callPackage ../development/libraries/martyr { };
|
2006-09-15 19:28:53 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
maven = callPackage ../misc/maven/maven-1.0.nix { };
|
|
|
|
maven2 = callPackage ../misc/maven { };
|
2010-11-19 16:24:11 +03:00
|
|
|
maven3 = callPackage ../misc/maven/3.0.nix { };
|
2007-12-19 03:17:40 +03:00
|
|
|
|
2010-08-11 23:47:05 +04:00
|
|
|
mess = callPackage ../misc/emulators/mess { };
|
|
|
|
|
2011-07-22 18:03:23 +04:00
|
|
|
mupen64plus = callPackage ../misc/emulators/mupen64plus { };
|
|
|
|
|
2010-08-17 19:21:42 +04:00
|
|
|
nix = nixStable;
|
2010-05-05 23:48:32 +04:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
nixStable = callPackage ../tools/package-management/nix {
|
2011-08-24 23:33:42 +04:00
|
|
|
storeDir = getConfig [ "nix" "storeDir" ] "/nix/store";
|
|
|
|
stateDir = getConfig [ "nix" "stateDir" ] "/nix/var";
|
2006-05-01 23:16:41 +04:00
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
nixUnstable = callPackage ../tools/package-management/nix/unstable.nix {
|
2011-08-24 23:33:42 +04:00
|
|
|
storeDir = getConfig [ "nix" "storeDir" ] "/nix/store";
|
|
|
|
stateDir = getConfig [ "nix" "stateDir" ] "/nix/var";
|
2006-11-17 15:49:46 +03:00
|
|
|
};
|
2010-09-17 19:56:15 +04:00
|
|
|
|
2011-02-11 15:45:19 +03:00
|
|
|
nixSqlite = nixUnstable;
|
2010-03-04 17:39:47 +03:00
|
|
|
|
2008-05-06 11:03:41 +04:00
|
|
|
nixCustomFun = src: preConfigure: enableScripts: configureFlags:
|
2008-02-21 16:44:06 +03:00
|
|
|
import ../tools/package-management/nix/custom.nix {
|
2008-06-19 02:48:34 +04:00
|
|
|
inherit fetchurl stdenv perl curl bzip2 openssl src preConfigure automake
|
2010-10-30 16:14:20 +04:00
|
|
|
autoconf libtool configureFlags enableScripts lib libxml2 boehmgc
|
2011-08-11 02:41:26 +04:00
|
|
|
pkgconfig flex bison sqlite perlPackages;
|
2009-12-10 17:50:50 +03:00
|
|
|
aterm = aterm25;
|
2008-02-21 16:44:06 +03:00
|
|
|
db4 = db45;
|
2009-09-19 16:35:52 +04:00
|
|
|
inherit docbook5_xsl libxslt docbook5 docbook_xml_dtd_43 w3m;
|
2008-02-21 16:44:06 +03:00
|
|
|
};
|
2007-11-13 18:52:16 +03:00
|
|
|
|
2011-06-14 06:41:01 +04:00
|
|
|
nut = callPackage ../applications/misc/nut { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
disnix = callPackage ../tools/package-management/disnix { };
|
2009-09-23 00:16:38 +04:00
|
|
|
|
2010-11-01 20:33:24 +03:00
|
|
|
disnix_activation_scripts = callPackage ../tools/package-management/disnix/activation-scripts {
|
|
|
|
enableApacheWebApplication = getConfig ["disnix" "enableApacheWebApplication"] false;
|
|
|
|
enableAxis2WebService = getConfig ["disnix" "enableAxis2WebService"] false;
|
|
|
|
enableEjabberdDump = getConfig ["disnix" "enableEjabberdDump"] false;
|
|
|
|
enableMySQLDatabase = getConfig ["disnix" "enableMySQLDatabase"] false;
|
2010-12-22 16:31:25 +03:00
|
|
|
enablePostgreSQLDatabase = getConfig ["disnix" "enablePostgreSQLDatabase"] false;
|
|
|
|
enableSubversionRepository = getConfig ["disnix" "enableSubversionRepository"] false;
|
2010-11-01 20:33:24 +03:00
|
|
|
enableTomcatWebApplication = getConfig ["disnix" "enableTomcatWebApplication"] false;
|
|
|
|
};
|
2008-07-08 03:11:13 +04:00
|
|
|
|
2010-12-17 21:42:02 +03:00
|
|
|
disnixos = callPackage ../tools/package-management/disnix/disnixos { };
|
2011-02-24 14:25:16 +03:00
|
|
|
|
2010-11-01 20:33:24 +03:00
|
|
|
DisnixWebService = callPackage ../tools/package-management/disnix/DisnixWebService { };
|
2008-07-08 03:11:13 +04:00
|
|
|
|
2012-02-04 13:31:07 +04:00
|
|
|
latex2html = callPackage ../tools/typesetting/tex/latex2html/default.nix {
|
2010-01-27 15:12:35 +03:00
|
|
|
tex = tetex;
|
|
|
|
};
|
|
|
|
|
2012-02-04 13:31:07 +04:00
|
|
|
lkproof = callPackage ../tools/typesetting/tex/lkproof { };
|
2010-12-25 21:06:36 +03:00
|
|
|
|
2010-10-04 13:49:25 +04:00
|
|
|
mysqlWorkbench = newScope gnome ../applications/misc/mysql-workbench {
|
2010-09-28 13:33:56 +04:00
|
|
|
lua = lua5;
|
|
|
|
inherit (pythonPackages) pexpect paramiko;
|
|
|
|
};
|
|
|
|
|
2011-06-28 13:45:51 +04:00
|
|
|
opkg = callPackage ../tools/package-management/opkg { };
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
pgadmin = callPackage ../applications/misc/pgadmin { };
|
2008-01-29 04:24:54 +03:00
|
|
|
|
2008-10-08 18:03:44 +04:00
|
|
|
pgf = pgf2;
|
|
|
|
|
|
|
|
# Keep the old PGF since some documents don't render properly with
|
|
|
|
# the new one.
|
2012-02-04 13:31:07 +04:00
|
|
|
pgf1 = callPackage ../tools/typesetting/tex/pgf/1.x.nix { };
|
2008-10-08 18:03:44 +04:00
|
|
|
|
2012-02-04 13:31:07 +04:00
|
|
|
pgf2 = callPackage ../tools/typesetting/tex/pgf/2.x.nix { };
|
2007-03-11 02:51:59 +03:00
|
|
|
|
2011-01-13 12:23:40 +03:00
|
|
|
pjsip = callPackage ../applications/networking/pjsip { };
|
|
|
|
|
2012-02-04 13:31:07 +04:00
|
|
|
polytable = callPackage ../tools/typesetting/tex/polytable { };
|
2005-10-21 17:06:43 +04:00
|
|
|
|
2011-06-26 23:49:51 +04:00
|
|
|
uae = callPackage ../misc/emulators/uae { };
|
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
putty = callPackage ../applications/networking/remote/putty { };
|
2007-05-28 18:10:46 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
rssglx = callPackage ../misc/screensavers/rss-glx { };
|
2006-03-02 21:17:45 +03:00
|
|
|
|
2011-07-22 00:58:41 +04:00
|
|
|
xlockmore = callPackage ../misc/screensavers/xlockmore { };
|
2008-02-15 13:40:20 +03:00
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
saneBackends = callPackage ../misc/sane-backends {
|
2008-03-17 12:41:28 +03:00
|
|
|
gt68xxFirmware = getConfig ["sane" "gt68xxFirmware"] null;
|
2011-12-08 06:55:40 +04:00
|
|
|
hotplugSupport = getConfig ["sane" "hotplugSupport"] true;
|
2007-08-09 00:33:36 +04:00
|
|
|
};
|
|
|
|
|
2011-12-05 21:32:45 +04:00
|
|
|
saneBackendsSnapshot = callPackage ../misc/sane-backends/snapshot.nix {
|
|
|
|
gt68xxFirmware = getConfig ["sane" "gt68xxFirmware"] null;
|
2007-08-09 00:33:36 +04:00
|
|
|
};
|
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
saneFrontends = callPackage ../misc/sane-front { };
|
2005-11-03 23:00:43 +03:00
|
|
|
|
2011-09-17 21:40:07 +04:00
|
|
|
slock = callPackage ../misc/screensavers/slock { };
|
|
|
|
|
2008-06-15 15:54:22 +04:00
|
|
|
sourceAndTags = import ../misc/source-and-tags {
|
2008-08-21 15:07:44 +04:00
|
|
|
inherit pkgs stdenv unzip lib ctags;
|
2009-07-10 02:23:51 +04:00
|
|
|
hasktags = haskellPackages.myhasktags;
|
2008-06-15 15:54:22 +04:00
|
|
|
};
|
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
splix = callPackage ../misc/cups/drivers/splix { };
|
2010-04-14 23:27:15 +04:00
|
|
|
|
2012-02-07 13:38:20 +04:00
|
|
|
tetex = callPackage ../tools/typesetting/tex/tetex { libpng = libpng12; };
|
2006-01-31 18:18:27 +03:00
|
|
|
|
2012-02-04 13:31:07 +04:00
|
|
|
tex4ht = callPackage ../tools/typesetting/tex/tex4ht { };
|
2010-01-31 15:13:33 +03:00
|
|
|
|
2012-02-04 13:31:07 +04:00
|
|
|
texFunctions = import ../tools/typesetting/tex/nix pkgs;
|
2006-01-28 05:10:26 +03:00
|
|
|
|
2012-02-04 13:31:07 +04:00
|
|
|
texLive = builderDefsPackage (import ../tools/typesetting/tex/texlive) {
|
2008-03-20 12:52:40 +03:00
|
|
|
inherit builderDefs zlib bzip2 ncurses libpng ed
|
2012-01-11 22:52:43 +04:00
|
|
|
gd t1lib freetype icu perl expat curl
|
2010-12-13 00:48:29 +03:00
|
|
|
libjpeg bison python fontconfig flex;
|
2008-03-20 12:52:40 +03:00
|
|
|
inherit (xlibs) libXaw libX11 xproto libXt libXpm
|
2008-08-25 18:52:53 +04:00
|
|
|
libXmu libXext xextproto libSM libICE;
|
2008-03-20 12:52:40 +03:00
|
|
|
ghostscript = ghostscriptX;
|
2012-01-11 22:52:43 +04:00
|
|
|
ruby = ruby18;
|
2008-03-20 12:52:40 +03:00
|
|
|
};
|
|
|
|
|
2012-01-20 00:45:17 +04:00
|
|
|
texLiveFull = lib.setName "texlive-full" (texLiveAggregationFun {
|
|
|
|
paths = [ texLive texLiveExtra lmodern texLiveCMSuper texLiveLatexXColor
|
|
|
|
texLivePGF texLiveBeamer texLiveModerncv ];
|
|
|
|
});
|
|
|
|
|
2008-06-19 02:48:34 +04:00
|
|
|
/* Look in configurations/misc/raskin.nix for usage example (around revisions
|
|
|
|
where TeXLive was added)
|
|
|
|
|
2008-03-22 16:04:04 +03:00
|
|
|
(texLiveAggregationFun {
|
2008-06-19 02:48:34 +04:00
|
|
|
paths = [texLive texLiveExtra texLiveCMSuper
|
2008-03-22 16:04:04 +03:00
|
|
|
texLiveBeamer
|
|
|
|
];
|
2008-08-15 02:04:30 +04:00
|
|
|
})
|
2008-05-16 08:52:47 +04:00
|
|
|
|
|
|
|
You need to use texLiveAggregationFun to regenerate, say, ls-R (TeX-related file list)
|
|
|
|
Just installing a few packages doesn't work.
|
2008-03-22 16:04:04 +03:00
|
|
|
*/
|
2008-08-25 17:25:07 +04:00
|
|
|
texLiveAggregationFun =
|
2012-02-04 13:31:07 +04:00
|
|
|
(builderDefsPackage (import ../tools/typesetting/tex/texlive/aggregate.nix));
|
2008-03-22 16:04:04 +03:00
|
|
|
|
2012-02-04 13:31:07 +04:00
|
|
|
texDisser = callPackage ../tools/typesetting/tex/disser {};
|
2011-09-13 00:50:32 +04:00
|
|
|
|
2012-02-04 13:31:07 +04:00
|
|
|
texLiveContext = builderDefsPackage (import ../tools/typesetting/tex/texlive/context.nix) {
|
2008-04-28 14:10:44 +04:00
|
|
|
inherit texLive;
|
|
|
|
};
|
|
|
|
|
2012-02-04 13:31:07 +04:00
|
|
|
texLiveExtra = builderDefsPackage (import ../tools/typesetting/tex/texlive/extra.nix) {
|
2008-03-22 16:04:04 +03:00
|
|
|
inherit texLive;
|
|
|
|
};
|
|
|
|
|
2012-02-04 13:31:07 +04:00
|
|
|
texLiveCMSuper = builderDefsPackage (import ../tools/typesetting/tex/texlive/cm-super.nix) {
|
2008-03-22 16:04:04 +03:00
|
|
|
inherit texLive;
|
|
|
|
};
|
|
|
|
|
2012-02-04 13:31:07 +04:00
|
|
|
texLiveLatexXColor = builderDefsPackage (import ../tools/typesetting/tex/texlive/xcolor.nix) {
|
2008-03-22 16:04:04 +03:00
|
|
|
inherit texLive;
|
|
|
|
};
|
|
|
|
|
2012-02-04 13:31:07 +04:00
|
|
|
texLivePGF = builderDefsPackage (import ../tools/typesetting/tex/texlive/pgf.nix) {
|
2008-03-22 16:04:04 +03:00
|
|
|
inherit texLiveLatexXColor texLive;
|
|
|
|
};
|
|
|
|
|
2012-02-04 13:31:07 +04:00
|
|
|
texLiveBeamer = builderDefsPackage (import ../tools/typesetting/tex/texlive/beamer.nix) {
|
2008-03-22 16:04:04 +03:00
|
|
|
inherit texLiveLatexXColor texLivePGF texLive;
|
|
|
|
};
|
2008-03-20 12:52:40 +03:00
|
|
|
|
2012-02-04 13:31:07 +04:00
|
|
|
texLiveModerncv = builderDefsPackage (import ../tools/typesetting/tex/texlive/moderncv.nix) {
|
2011-07-13 20:23:48 +04:00
|
|
|
inherit texLive unzip;
|
2011-07-13 19:00:59 +04:00
|
|
|
};
|
|
|
|
|
2010-08-03 01:40:34 +04:00
|
|
|
trac = callPackage ../misc/trac {
|
2009-07-08 02:34:03 +04:00
|
|
|
inherit (pythonPackages) pysqlite;
|
2009-08-28 10:29:21 +04:00
|
|
|
};
|
2008-06-19 02:48:34 +04:00
|
|
|
|
2010-09-09 20:48:13 +04:00
|
|
|
vice = callPackage ../misc/emulators/vice { };
|
2008-06-19 02:48:34 +04:00
|
|
|
|
2012-01-05 02:12:43 +04:00
|
|
|
vimprobable2 = callPackage ../applications/networking/browsers/vimprobable2 {
|
2012-03-08 20:49:08 +04:00
|
|
|
inherit (gnome) libsoup;
|
2012-01-05 02:12:43 +04:00
|
|
|
};
|
|
|
|
|
2011-07-22 22:31:42 +04:00
|
|
|
VisualBoyAdvance = callPackage ../misc/emulators/VisualBoyAdvance { };
|
2011-07-25 00:26:33 +04:00
|
|
|
|
2010-08-11 17:25:30 +04:00
|
|
|
# Wine cannot be built in 64-bit; use a 32-bit build instead.
|
2010-12-13 00:48:29 +03:00
|
|
|
wine = callPackage_i686 ../misc/emulators/wine { };
|
2007-06-26 01:46:18 +04:00
|
|
|
|
2010-12-13 00:48:29 +03:00
|
|
|
wineWarcraft = callPackage_i686 ../misc/emulators/wine/wine-warcraft.nix { };
|
2010-09-26 09:05:18 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
x2x = callPackage ../tools/X11/x2x { };
|
2010-05-16 20:23:17 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
xosd = callPackage ../misc/xosd { };
|
2008-03-29 03:49:26 +03:00
|
|
|
|
2012-03-08 01:59:48 +04:00
|
|
|
xsane = callPackage ../misc/xsane {
|
|
|
|
libpng = libpng12;
|
|
|
|
};
|
2007-08-09 00:33:36 +04:00
|
|
|
|
* Use callPackage for most packages in all-packages.nix.
`callPackage' was described here:
http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html
It allows all-packages.nix to be shortened significantly (from 10152
to 6980 lines) by automatically filling in package functions'
required arguments from `pkgs'. That is, a function
{ stdenv, fetchurl, libfoo, libbar }: ...
can now be called as
callPackage ./<bla>.nix { };
rather than
import ./<bla>.nix {
inherit stdenv fetchurl libfoo libbar;
};
This reduces boring typing work when adding a dependency and reduces
the number of trivial commits to all-packages.nix.
Overrides or arguments that don't exist in `pkgs' can be passed
explicitly, e.g.,
callPackage ./<bla>.nix {
libfoo = libfoo_1_2_3;
};
The conversion was done automatically with a magic Perl regexp. I
checked that `nix-env' produces the same results before and after
(except for three packages that depend on webkit, which uses
deepOverride).
`callPackage' applies `makeOverridable' automatically, so almost
every package now exports an `override' function.
There are two downsides to using callPackage:
- Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path
\*').
- There can be unexpected results for functions that have default
argument values. For instance, a function
{ libfoo ? null }: ...
called using `callPackage' will be passed a `libfoo' argument
provided that `pkgs.libfoo' exists. If this is used to control
whether a package has to have a certain dependency, you need to
explicitly write:
callPackage ./<bla>.nix {
libfoo = null;
};
svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 20:26:58 +04:00
|
|
|
yafc = callPackage ../applications/networking/yafc { };
|
2009-01-25 17:31:51 +03:00
|
|
|
|
2008-10-10 02:57:20 +04:00
|
|
|
myEnvFun = import ../misc/my-env {
|
|
|
|
inherit substituteAll pkgs;
|
|
|
|
inherit (stdenv) mkDerivation;
|
|
|
|
};
|
2008-06-15 15:54:22 +04:00
|
|
|
|
2011-06-26 02:25:50 +04:00
|
|
|
zsnes = callPackage_i686 ../misc/emulators/zsnes { };
|
|
|
|
|
2009-07-08 00:53:16 +04:00
|
|
|
misc = import ../misc/misc.nix { inherit pkgs stdenv; };
|
2009-04-17 17:48:22 +04:00
|
|
|
|
2012-02-19 14:51:04 +04:00
|
|
|
bullet = callPackage ../development/libraries/bullet {};
|
|
|
|
|
2008-03-17 20:29:07 +03:00
|
|
|
}; in pkgs
|