alioth/nixpkgs
3
0
Fork 0
forked from mirrors/nixpkgs
Code Releases Activity
nixpkgs/pkgs/top-level/all-packages.nix

7026 lines
207 KiB
Nix
Raw Normal View History

* Merge all-packages.nix into all-packages-generic.nix. svn path=/nixpkgs/branches/usability/; revision=4765
2006-02-08 17:37:45 +00: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
* Remove `customKernel' which is obsolete as far as I can tell. * Remove `sumTwoArgs' since it has no remaining callers. svn path=/nixpkgs/trunk/; revision=22797
2010-07-28 17:09:13 +01:00
platform. */
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
* Merge all-packages.nix into all-packages-generic.nix. svn path=/nixpkgs/branches/usability/; revision=4765
2006-02-08 17:37:45 +00:00
* Support different kinds of stdenvs on a particular system (like "i686-cygwin") by adding an argument "stdenvType" to specify which stdenv to use (like "i686-mingw"). svn path=/nixpkgs/trunk/; revision=6213
2006-08-23 16:58:54 +01:00
{ # The system (e.g., `i686-linux') for which to build the packages.
* __XXX primops are deprecated. svn path=/nixpkgs/trunk/; revision=15036
2009-04-14 14:59:45 +01:00
system ? builtins.currentSystem
* Converting packages. This is the minimal Nix stdenv for building the ATerm library. svn path=/nixpkgs/trunk/; revision=459
2003-11-02 17:42:19 +00:00
* Support different kinds of stdenvs on a particular system (like "i686-cygwin") by adding an argument "stdenvType" to specify which stdenv to use (like "i686-mingw"). svn path=/nixpkgs/trunk/; revision=6213
2006-08-23 16:58:54 +01: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
* Merge all-packages.nix into all-packages-generic.nix. svn path=/nixpkgs/branches/usability/; revision=4765
2006-02-08 17:37:45 +00: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
* The `patch' command is now part of stdenv, so it no longer needs to be passed to derivations that need to apply patches. * GCC 3.4 is now the default compiler (old GCC renamed to `gcc-3.3'). * The temporary GCCs built during the stdenvLinux bootstrap are now built without C++ support and without profiling. * Remove fixincl in GCC 3.4 to prevent a retained dependency on the previous GCC. * Always set $prefix in setup.sh, even when there is no configure script. svn path=/nixpkgs/trunk/; revision=1444
2004-09-18 18:23:18 +01:00
, gccWithCC ? true
, gccWithProfiling ? true
* Finally got stdenv-nix-linux working again. Still not perfect, though. * libxml2: upgrade to latest. * octavefront/rna: keep debug info. svn path=/nixpkgs/trunk/; revision=830
2004-03-11 17:26:14 +00:00
* Allow the Nixpkgs config to be passed as a function argument (rather than through ~/.nixpkgs/config.nix or $NIXPKGS_CONFIG). svn path=/nixpkgs/trunk/; revision=16861
2009-08-26 14:51:37 +01: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
* Fix Perl on FreeBSD. svn path=/nixpkgs/branches/stdenv-updates/; revision=19685
2010-01-26 18:10:59 +00: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-17 22:58:48 +00:00
, crossSystem ? null
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 17:35:47 +00:00
, platform ? (import ./platforms.nix).pc
* Merge all-packages.nix into all-packages-generic.nix. svn path=/nixpkgs/branches/usability/; revision=4765
2006-02-08 17:37:45 +00:00
}:
* Updated to reflect the changes to the grammar. svn path=/nixpkgs/trunk/; revision=464
2003-11-03 10:22:00 +00:00
* Use all those new packages. svn path=/nixpkgs/trunk/; revision=545
2003-11-25 18:02:05 +00:00
* Allow the Nixpkgs config to be passed as a function argument (rather than through ~/.nixpkgs/config.nix or $NIXPKGS_CONFIG). svn path=/nixpkgs/trunk/; revision=16861
2009-08-26 14:51:37 +01:00
let config_ = config; in # rename the function argument
* Allow packages to be overriden globally via the `packageOverrides' configuration option. For instance, to override GCC globally for all of Nixpkgs, you can put the following in ~/.nixpkgs/config.nix: { packageOverrides = pkgs: { gcc = pkgs.gcc41; } } This should make a lot of configuration support in Nixpkgs unnecessary, like selectVersion and many little-used configuration options. It also provides a somewhat convenient place to put custom, private additions to Nixpkgs, e.g. { packageOverrides = pkgs: { myHello = pkgs.stdenv.mkDerivation { name = "my-hello-0.1"; buildCommand = ...; }; }; }; Note that this requires Nix >= 0.12pre12726. * Removed the `myPackages' option `packageOverrides' obsoletes it. svn path=/nixpkgs/trunk/; revision=12727
2008-08-26 16:35:00 +01:00
let
* Added the Dutch Tax Return program for 2009. svn path=/nixpkgs/trunk/; revision=20828
2010-03-25 19:40:19 +00:00
lib = import ../lib;
* Allow packages to be overriden globally via the `packageOverrides' configuration option. For instance, to override GCC globally for all of Nixpkgs, you can put the following in ~/.nixpkgs/config.nix: { packageOverrides = pkgs: { gcc = pkgs.gcc41; } } This should make a lot of configuration support in Nixpkgs unnecessary, like selectVersion and many little-used configuration options. It also provides a somewhat convenient place to put custom, private additions to Nixpkgs, e.g. { packageOverrides = pkgs: { myHello = pkgs.stdenv.mkDerivation { name = "my-hello-0.1"; buildCommand = ...; }; }; }; Note that this requires Nix >= 0.12pre12726. * Removed the `myPackages' option `packageOverrides' obsoletes it. svn path=/nixpkgs/trunk/; revision=12727
2008-08-26 16:35:00 +01:00
# The contents of the configuration file found at $NIXPKGS_CONFIG or
# $HOME/.nixpkgs/config.nix.
adding hint telling where to set config for nixos svn path=/nixpkgs/trunk/; revision=17337
2009-09-21 16:55:18 +01:00
# for NIXOS (nixos-rebuild): use nixpkgs.config option
* Allow packages to be overriden globally via the `packageOverrides' configuration option. For instance, to override GCC globally for all of Nixpkgs, you can put the following in ~/.nixpkgs/config.nix: { packageOverrides = pkgs: { gcc = pkgs.gcc41; } } This should make a lot of configuration support in Nixpkgs unnecessary, like selectVersion and many little-used configuration options. It also provides a somewhat convenient place to put custom, private additions to Nixpkgs, e.g. { packageOverrides = pkgs: { myHello = pkgs.stdenv.mkDerivation { name = "my-hello-0.1"; buildCommand = ...; }; }; }; Note that this requires Nix >= 0.12pre12726. * Removed the `myPackages' option `packageOverrides' obsoletes it. svn path=/nixpkgs/trunk/; revision=12727
2008-08-26 16:35:00 +01:00
config =
* Allow the Nixpkgs config to be passed as a function argument (rather than through ~/.nixpkgs/config.nix or $NIXPKGS_CONFIG). svn path=/nixpkgs/trunk/; revision=16861
2009-08-26 14:51:37 +01:00
let
* Allow packages to be overriden globally via the `packageOverrides' configuration option. For instance, to override GCC globally for all of Nixpkgs, you can put the following in ~/.nixpkgs/config.nix: { packageOverrides = pkgs: { gcc = pkgs.gcc41; } } This should make a lot of configuration support in Nixpkgs unnecessary, like selectVersion and many little-used configuration options. It also provides a somewhat convenient place to put custom, private additions to Nixpkgs, e.g. { packageOverrides = pkgs: { myHello = pkgs.stdenv.mkDerivation { name = "my-hello-0.1"; buildCommand = ...; }; }; }; Note that this requires Nix >= 0.12pre12726. * Removed the `myPackages' option `packageOverrides' obsoletes it. svn path=/nixpkgs/trunk/; revision=12727
2008-08-26 16:35:00 +01: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";
allow { pkgs, pkgsOrig, ... } : in config.nix svn path=/nixpkgs/trunk/; revision=14700
2009-03-25 13:29:47 +00:00
configExpr =
* Allow the Nixpkgs config to be passed as a function argument (rather than through ~/.nixpkgs/config.nix or $NIXPKGS_CONFIG). svn path=/nixpkgs/trunk/; revision=16861
2009-08-26 14:51:37 +01:00
if config_ != null then config_
else if configFile != "" && pathExists configFile then import (toPath configFile)
else if homeDir != "" && pathExists configFile2 then import (toPath configFile2)
* Allow packages to be overriden globally via the `packageOverrides' configuration option. For instance, to override GCC globally for all of Nixpkgs, you can put the following in ~/.nixpkgs/config.nix: { packageOverrides = pkgs: { gcc = pkgs.gcc41; } } This should make a lot of configuration support in Nixpkgs unnecessary, like selectVersion and many little-used configuration options. It also provides a somewhat convenient place to put custom, private additions to Nixpkgs, e.g. { packageOverrides = pkgs: { myHello = pkgs.stdenv.mkDerivation { name = "my-hello-0.1"; buildCommand = ...; }; }; }; Note that this requires Nix >= 0.12pre12726. * Removed the `myPackages' option `packageOverrides' obsoletes it. svn path=/nixpkgs/trunk/; revision=12727
2008-08-26 16:35:00 +01:00
else {};
allow { pkgs, pkgsOrig, ... } : in config.nix svn path=/nixpkgs/trunk/; revision=14700
2009-03-25 13:29:47 +00:00
* Allow the Nixpkgs config to be passed as a function argument (rather than through ~/.nixpkgs/config.nix or $NIXPKGS_CONFIG). svn path=/nixpkgs/trunk/; revision=16861
2009-08-26 14:51:37 +01:00
in
allow { pkgs, pkgsOrig, ... } : in config.nix svn path=/nixpkgs/trunk/; revision=14700
2009-03-25 13:29:47 +00:00
# allow both:
# { /* the config */ } and
# { pkgsOrig, pkgs, ... } : { /* the config */ }
* Allow the Nixpkgs config to be passed as a function argument (rather than through ~/.nixpkgs/config.nix or $NIXPKGS_CONFIG). svn path=/nixpkgs/trunk/; revision=16861
2009-08-26 14:51:37 +01:00
if builtins.isFunction configExpr
allow { pkgs, pkgsOrig, ... } : in config.nix svn path=/nixpkgs/trunk/; revision=14700
2009-03-25 13:29:47 +00:00
then configExpr { inherit pkgs pkgsOrig; }
else configExpr;
* Allow packages to be overriden globally via the `packageOverrides' configuration option. For instance, to override GCC globally for all of Nixpkgs, you can put the following in ~/.nixpkgs/config.nix: { packageOverrides = pkgs: { gcc = pkgs.gcc41; } } This should make a lot of configuration support in Nixpkgs unnecessary, like selectVersion and many little-used configuration options. It also provides a somewhat convenient place to put custom, private additions to Nixpkgs, e.g. { packageOverrides = pkgs: { myHello = pkgs.stdenv.mkDerivation { name = "my-hello-0.1"; buildCommand = ...; }; }; }; Note that this requires Nix >= 0.12pre12726. * Removed the `myPackages' option `packageOverrides' obsoletes it. svn path=/nixpkgs/trunk/; revision=12727
2008-08-26 16:35:00 +01:00
# Return an attribute from the Nixpkgs configuration file, or
# a default value if the attribute doesn't exist.
big breaking change: renaming lib.getAttr to lib.attrByPath getAttr was ambiguous. It's also a builtin function fix svn path=/nixpkgs/trunk/; revision=15692
2009-05-24 11:57:41 +01:00
getConfig = attrPath: default: lib.attrByPath attrPath default config;
* Allow packages to be overriden globally via the `packageOverrides' configuration option. For instance, to override GCC globally for all of Nixpkgs, you can put the following in ~/.nixpkgs/config.nix: { packageOverrides = pkgs: { gcc = pkgs.gcc41; } } This should make a lot of configuration support in Nixpkgs unnecessary, like selectVersion and many little-used configuration options. It also provides a somewhat convenient place to put custom, private additions to Nixpkgs, e.g. { packageOverrides = pkgs: { myHello = pkgs.stdenv.mkDerivation { name = "my-hello-0.1"; buildCommand = ...; }; }; }; Note that this requires Nix >= 0.12pre12726. * Removed the `myPackages' option `packageOverrides' obsoletes it. svn path=/nixpkgs/trunk/; revision=12727
2008-08-26 16:35:00 +01:00
* Move functions like `runCommand' out of all-packages.nix and into build-support/. svn path=/nixpkgs/trunk/; revision=18465
2009-11-19 16:07:47 +00:00
# Helper functions that are exported through `pkgs'.
pkgs/applications/editors/emacs-modes/prolog: initial version of prolog-mode for Emacs svn path=/nixpkgs/trunk/; revision=18675
2009-11-27 17:40:56 +00:00
helperFunctions =
* Export the stdenv adapter functions. * Add a "kernel" attribute containing the default kernel to make it easier to override. svn path=/nixpkgs/trunk/; revision=19189
2010-01-03 17:56:55 +00:00
stdenvAdapters //
* Move functions like `runCommand' out of all-packages.nix and into build-support/. svn path=/nixpkgs/trunk/; revision=18465
2009-11-19 16:07:47 +00:00
(import ../build-support/trivial-builders.nix { inherit (pkgs) stdenv; inherit (pkgs.xorg) lndir; });
* Export the stdenv adapter functions. * Add a "kernel" attribute containing the default kernel to make it easier to override. svn path=/nixpkgs/trunk/; revision=19189
2010-01-03 17:56:55 +00:00
stdenvAdapters =
import ../stdenv/adapters.nix { inherit (pkgs) dietlibc fetchurl runCommand; };
* Move functions like `runCommand' out of all-packages.nix and into build-support/. svn path=/nixpkgs/trunk/; revision=18465
2009-11-19 16:07:47 +00:00
* Allow packages to be overriden globally via the `packageOverrides' configuration option. For instance, to override GCC globally for all of Nixpkgs, you can put the following in ~/.nixpkgs/config.nix: { packageOverrides = pkgs: { gcc = pkgs.gcc41; } } This should make a lot of configuration support in Nixpkgs unnecessary, like selectVersion and many little-used configuration options. It also provides a somewhat convenient place to put custom, private additions to Nixpkgs, e.g. { packageOverrides = pkgs: { myHello = pkgs.stdenv.mkDerivation { name = "my-hello-0.1"; buildCommand = ...; }; }; }; Note that this requires Nix >= 0.12pre12726. * Removed the `myPackages' option `packageOverrides' obsoletes it. svn path=/nixpkgs/trunk/; revision=12727
2008-08-26 16:35:00 +01: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.
# `__overrides' is a magic attribute that causes the attributes in
* Quick proof-of-concept of making it easy to override package configuration options in ~/.nixpkgs/config.nix. Example: { packageOverrides = pkgs: { subversion = pkgs.subversion.function (origArgs: { bdbSupport = false; pythonBindings = !origArgs.pythonBindings; }); }; } I.e. pkgs.subversion.function is the original function call to the Subversion function in all-packages.nix. This requires the "subversion" attribute to use makeOverridable, which stores the original function and function arguments in the "function" attribute of the result. svn path=/nixpkgs/trunk/; revision=12728
2008-08-26 17:50:33 +01:00
# its value to be added to the surrounding `rec'. The
# `packageOverrides' function is called with the *original*
# (un-overriden) set of packages, allowing packageOverrides
# attributes to refer to the original attributes (e.g. "foo =
# ... pkgs.foo ...").
Fix the cross-building of packages mentioned in stdenvLinux.overrides. svn path=/nixpkgs/trunk/; revision=23038
2010-08-08 18:26:30 +01:00
# 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.
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
overrides = (getConfig ["packageOverrides"] (pkgs: {})) pkgsOrig //
Fix the cross-building of packages mentioned in stdenvLinux.overrides. svn path=/nixpkgs/trunk/; revision=23038
2010-08-08 18:26:30 +01:00
(if (pkgsOrig.stdenv ? overrides && crossSystem == null)
then pkgsOrig.stdenv.overrides else { });
* Quick proof-of-concept of making it easy to override package configuration options in ~/.nixpkgs/config.nix. Example: { packageOverrides = pkgs: { subversion = pkgs.subversion.function (origArgs: { bdbSupport = false; pythonBindings = !origArgs.pythonBindings; }); }; } I.e. pkgs.subversion.function is the original function call to the Subversion function in all-packages.nix. This requires the "subversion" attribute to use makeOverridable, which stores the original function and function arguments in the "function" attribute of the result. svn path=/nixpkgs/trunk/; revision=12728
2008-08-26 17:50:33 +01:00
pkgsOrig = pkgsFun {}; # the un-overriden packages, passed to packageOverrides
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
pkgs = pkgsFun overrides; # the overriden, final packages
maudeUnstable: updated full-maude to latest alpha release svn path=/nixpkgs/trunk/; revision=13017
2008-10-09 11:10:49 +01:00
* Allow packages to be overriden globally via the `packageOverrides' configuration option. For instance, to override GCC globally for all of Nixpkgs, you can put the following in ~/.nixpkgs/config.nix: { packageOverrides = pkgs: { gcc = pkgs.gcc41; } } This should make a lot of configuration support in Nixpkgs unnecessary, like selectVersion and many little-used configuration options. It also provides a somewhat convenient place to put custom, private additions to Nixpkgs, e.g. { packageOverrides = pkgs: { myHello = pkgs.stdenv.mkDerivation { name = "my-hello-0.1"; buildCommand = ...; }; }; }; Note that this requires Nix >= 0.12pre12726. * Removed the `myPackages' option `packageOverrides' obsoletes it. svn path=/nixpkgs/trunk/; revision=12727
2008-08-26 16:35:00 +01:00
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01: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);
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01:00
defaultScope = pkgs // pkgs.xorg;
* Allow packages to be overriden globally via the `packageOverrides' configuration option. For instance, to override GCC globally for all of Nixpkgs, you can put the following in ~/.nixpkgs/config.nix: { packageOverrides = pkgs: { gcc = pkgs.gcc41; } } This should make a lot of configuration support in Nixpkgs unnecessary, like selectVersion and many little-used configuration options. It also provides a somewhat convenient place to put custom, private additions to Nixpkgs, e.g. { packageOverrides = pkgs: { myHello = pkgs.stdenv.mkDerivation { name = "my-hello-0.1"; buildCommand = ...; }; }; }; Note that this requires Nix >= 0.12pre12726. * Removed the `myPackages' option `packageOverrides' obsoletes it. svn path=/nixpkgs/trunk/; revision=12727
2008-08-26 16:35:00 +01:00
# The package compositions. Yes, this isn't properly indented.
* Drop pkgsOverriden. svn path=/nixpkgs/trunk/; revision=22823
2010-07-30 13:10:24 +01:00
pkgsFun = __overrides: with helperFunctions; helperFunctions // rec {
* Allow packages to be overriden globally via the `packageOverrides' configuration option. For instance, to override GCC globally for all of Nixpkgs, you can put the following in ~/.nixpkgs/config.nix: { packageOverrides = pkgs: { gcc = pkgs.gcc41; } } This should make a lot of configuration support in Nixpkgs unnecessary, like selectVersion and many little-used configuration options. It also provides a somewhat convenient place to put custom, private additions to Nixpkgs, e.g. { packageOverrides = pkgs: { myHello = pkgs.stdenv.mkDerivation { name = "my-hello-0.1"; buildCommand = ...; }; }; }; Note that this requires Nix >= 0.12pre12726. * Removed the `myPackages' option `packageOverrides' obsoletes it. svn path=/nixpkgs/trunk/; revision=12727
2008-08-26 16:35:00 +01:00
pkgs/top-level/all-packages.nix: strip trailing whitespace svn path=/nixpkgs/trunk/; revision=23000
2010-08-06 13:47:20 +01:00
* Added the Dutch Tax Return program for 2009. svn path=/nixpkgs/trunk/; revision=20828
2010-03-25 19:40:19 +00:00
# Override system. This is useful to build i686 packages on x86_64-linux.
provide pkgsi686Linux attr for convinience.. svn path=/nixpkgs/trunk/; revision=19197
2010-01-04 07:44:30 +00:00
forceSystem = system: (import ./all-packages.nix) {
inherit system;
inherit bootStdenv noSysDirs gccWithCC gccWithProfiling config;
};
* Added the Dutch Tax Return program for 2009. svn path=/nixpkgs/trunk/; revision=20828
2010-03-25 19:40:19 +00:00
# Used by wine, firefox with debugging version of Flash, ...
provide pkgsi686Linux attr for convinience.. svn path=/nixpkgs/trunk/; revision=19197
2010-01-04 07:44:30 +00:00
pkgsi686Linux = forceSystem "i686-linux";
* Allow packages to be overriden globally via the `packageOverrides' configuration option. For instance, to override GCC globally for all of Nixpkgs, you can put the following in ~/.nixpkgs/config.nix: { packageOverrides = pkgs: { gcc = pkgs.gcc41; } } This should make a lot of configuration support in Nixpkgs unnecessary, like selectVersion and many little-used configuration options. It also provides a somewhat convenient place to put custom, private additions to Nixpkgs, e.g. { packageOverrides = pkgs: { myHello = pkgs.stdenv.mkDerivation { name = "my-hello-0.1"; buildCommand = ...; }; }; }; Note that this requires Nix >= 0.12pre12726. * Removed the `myPackages' option `packageOverrides' obsoletes it. svn path=/nixpkgs/trunk/; revision=12727
2008-08-26 16:35:00 +01:00
* Use callPackage_i686 for i686-only packages. svn path=/nixpkgs/trunk/; revision=23113
2010-08-11 14:25:30 +01:00
callPackage_i686 = lib.callPackageWith (pkgsi686Linux // pkgsi686Linux.xorg);
* Allow packages to be overriden globally via the `packageOverrides' configuration option. For instance, to override GCC globally for all of Nixpkgs, you can put the following in ~/.nixpkgs/config.nix: { packageOverrides = pkgs: { gcc = pkgs.gcc41; } } This should make a lot of configuration support in Nixpkgs unnecessary, like selectVersion and many little-used configuration options. It also provides a somewhat convenient place to put custom, private additions to Nixpkgs, e.g. { packageOverrides = pkgs: { myHello = pkgs.stdenv.mkDerivation { name = "my-hello-0.1"; buildCommand = ...; }; }; }; Note that this requires Nix >= 0.12pre12726. * Removed the `myPackages' option `packageOverrides' obsoletes it. svn path=/nixpkgs/trunk/; revision=12727
2008-08-26 16:35:00 +01:00
inherit __overrides;
# For convenience, allow callers to get the path to Nixpkgs.
* It makes more sense for "path" to point at the top of the Nixpkgs tree, rather than the pkgs subdirectory. svn path=/nixpkgs/trunk/; revision=15893
2009-06-08 23:43:27 +01:00
path = ../..;
* Use all those new packages. svn path=/nixpkgs/trunk/; revision=545
2003-11-25 18:02:05 +00:00
maudeUnstable: updated full-maude to latest alpha release svn path=/nixpkgs/trunk/; revision=13017
2008-10-09 11:10:49 +01:00
* Started moving from XFree86 to the freedesktop.org Xlibs libraries. svn path=/nixpkgs/trunk/; revision=860
2004-03-27 21:59:31 +00:00
### Symbolic names.
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
x11 = xlibsWrapper;
* Start the switch to the new X libraries. It's still conditional: set `useOldXLibs' to `false' in all-packages-generic.nix to use them. * Added Xaw3d. * Added Xaw3d support to Emacs. svn path=/nixpkgs/trunk/; revision=4263
2005-11-12 17:05:51 +00: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.).
* Remove the old modular X libraries. svn path=/nixpkgs/trunk/; revision=5729
2006-07-17 13:46:39 +01:00
xlibs = xorg // {xlibs = xlibsWrapper;};
* Start the switch to the new X libraries. It's still conditional: set `useOldXLibs' to `false' in all-packages-generic.nix to use them. * Added Xaw3d. * Added Xaw3d support to Emacs. svn path=/nixpkgs/trunk/; revision=4263
2005-11-12 17:05:51 +00:00
* Merge all-packages.nix into all-packages-generic.nix. svn path=/nixpkgs/branches/usability/; revision=4765
2006-02-08 17:37:45 +00:00
* Push packages from the final stdenv bootstrapping phase to all-packages. That is, an attribute like "bash" in all-packages.nix should evaluate to the "bash" used to build stdenv, it shouldn't build a new one. Hm, this would be a lot cleaner if we had lazy_rec ;-) svn path=/nixpkgs/branches/usability/; revision=4775
2006-02-09 17:04:18 +00:00
### Helper functions.
* Recurse into xorg, gnome, gtkLibs (i.e., they show up in nix-env operations). svn path=/nixpkgs/branches/usability/; revision=5085
2006-03-23 16:47:34 +00:00
* Export the stdenv adapter functions. * Add a "kernel" attribute containing the default kernel to make it easier to override. svn path=/nixpkgs/trunk/; revision=19189
2010-01-03 17:56:55 +00:00
inherit lib config getConfig stdenvAdapters;
maudeUnstable: updated full-maude to latest alpha release svn path=/nixpkgs/trunk/; revision=13017
2008-10-09 11:10:49 +01:00
Give Org-Mode a high priority. svn path=/nixpkgs/trunk/; revision=22694
2010-07-22 09:59:46 +01:00
inherit (lib) lowPrio hiPrio appendToName makeOverridable;
* A function `useDietLibC' that returns a modified stdenv that uses dietlibc to produce small, statically linked binaries. This stdenv also passes `-Os' to GCC automatically to optimise for size. It also tries to prevent builders from linking against dynamic libraries (which dietlibc doesn't support). * A function `addAttrsToDerivation' that returns a modified stdenv that always adds the specified attributes to the derivations that it produces. Example (from curl): curlDiet = import ../tools/networking/curl { inherit fetchurl zlib; stdenv = addAttrsToDerivation { CFLAGS = "-DHAVE_INET_NTOA_R_2_ARGS=1"; } (useDietLibC stdenv); }; (This is needed to get curl to build with dietlibc. Also note the stacking of stdenv-modifying functions.) * curl-diet: no longer necessary. svn path=/nixpkgs/trunk/; revision=6761
2006-10-18 13:50:04 +01:00
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
# Applying this to an attribute set will cause nix-env to look
# inside the set for derivations.
recurseIntoAttrs = attrs: attrs // {recurseForDerivations = true;};
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
# Return the first available value in the order: pkg.val, val, or default.
getPkgConfig = pkg : val : default : (getConfig [ pkg val ] (getConfig [ val ] default));
* composedArgsAndFun -> makeOverridable for consistency. * Rename a few single-version packages to "default.nix". svn path=/nixpkgs/trunk/; revision=22803
2010-07-29 09:21:21 +01:00
builderDefs = lib.composedArgsAndFun (import ../build-support/builder-defs/builder-defs.nix) {
xlock: fixed build and updated to version 5.24 svn path=/nixpkgs/trunk/; revision=17356
2009-09-22 21:16:38 +01:00
inherit stringsWithDeps lib stdenv writeScript
Adding fetchmtn, including fetchmtn and fetchgit in builder-defs, updating monotone-viz. Adding dadadodo. svn path=/nixpkgs/trunk/; revision=16207
2009-07-07 11:04:32 +01:00
fetchurl fetchmtn fetchgit;
* Clean up indentation (expanded tabs etc.). svn path=/nixpkgs/trunk/; revision=11150
2008-03-17 09:41:28 +00:00
};
Changed builderDefs to use composedArgsAndFun, reduced number of nulls, made overrides in builderDefsPackage to work in an intuitive manner. svn path=/nixpkgs/trunk/; revision=12655
2008-08-19 06:54:09 +01:00
builderDefsPackage = builderDefs.builderDefsPackage builderDefs;
Some refactorings in builderDefs. Psi is a simple showcase. TeXLive now works as far as English is concerned, and it is also updated up to newest builderDefs. svn path=/nixpkgs/trunk/; revision=11235
2008-03-20 15:40:26 +00:00
* Put strings-with-deps in lib. svn path=/nixpkgs/trunk/; revision=15729
2009-05-25 19:22:19 +01:00
stringsWithDeps = lib.stringsWithDeps;
Added a new setup proposal, builder is no more derived from shell script (where edit=glibc rebuild), but is composed from a nix attribute set with strings and dependencies - so if you add a function, old expressions ignore it; collateral damage are packages in this style: Fastest Fourier Transform in the West, Audacity sound editor, Falling Sand game. Also added string equality that ignores dependencies to lib. Note that hasSuffixHack is now the more predictable version, but hasSuffix is left to remind us to fix the bug. svn path=/nixpkgs/trunk/; revision=9549
2007-10-29 10:52:04 +00:00
xlock: fixed build and updated to version 5.24 svn path=/nixpkgs/trunk/; revision=17356
2009-09-22 21:16:38 +01:00
* Merge all-packages.nix into all-packages-generic.nix. svn path=/nixpkgs/branches/usability/; revision=4765
2006-02-08 17:37:45 +00:00
### STANDARD ENVIRONMENT
* Folded the Cygwin, powerpc-darwin and FreeBSD stdenv into the "native" stdenv. svn path=/nixpkgs/trunk/; revision=12147
2008-06-18 16:09:13 +01:00
allStdenvs = import ../stdenv {
inherit system stdenvType;
* Allow the Nixpkgs config to be passed as a function argument (rather than through ~/.nixpkgs/config.nix or $NIXPKGS_CONFIG). svn path=/nixpkgs/trunk/; revision=16861
2009-08-26 14:51:37 +01:00
allPackages = args: import ./all-packages.nix ({ inherit config; } // args);
* Folded the Cygwin, powerpc-darwin and FreeBSD stdenv into the "native" stdenv. svn path=/nixpkgs/trunk/; revision=12147
2008-06-18 16:09:13 +01: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 17:35:47 +00:00
defaultStdenv = allStdenvs.stdenv // { inherit platform; };
* Merge all-packages.nix into all-packages-generic.nix. svn path=/nixpkgs/branches/usability/; revision=4765
2006-02-08 17:37:45 +00:00
I removed the function-shape of the cross-toolchain related attributes in the all-packages.nix. That was more complicating than helping. svn path=/nixpkgs/trunk/; revision=20457
2010-03-06 23:36:55 +00: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 19:03:34 +00:00
pkgs/top-level/all-packages.nix: switch to Python 2.6 (except on Darwin) MacOS X can build Python 2.6 just fine, but for some reason a lot of modules don't work, so the resulting binary isn't very useful. svn path=/nixpkgs/branches/stdenv-updates/; revision=19598
2010-01-21 15:39:11 +00:00
stdenv =
* Linux 2.6.21.7. svn path=/nixpkgs/trunk/; revision=9176
2007-08-20 15:26:32 +01:00
if bootStdenv != null then bootStdenv else
let changer = getConfig ["replaceStdenv"] null;
in if changer != null then
changer {
- 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 19:03:34 +00:00
stdenv = stdenvCross;
* Linux 2.6.21.7. svn path=/nixpkgs/trunk/; revision=9176
2007-08-20 15:26:32 +01:00
overrideSetup = overrideSetup;
}
Making the cross-stdenv not to be used unless cross-compiling. This way, no "hostDrv" or "buildDrv" attributes are added to derivations. svn path=/nixpkgs/trunk/; revision=19866
2010-02-08 15:28:05 +00:00
else if crossSystem != null then
stdenvCross
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-17 22:58:48 +00:00
Removing a dependency on stdenvCross: there was a .buildDrv mentioned when there was no cross build planned. svn path=/nixpkgs/trunk/; revision=19871
2010-02-09 07:43:36 +00: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 19:51:45 +00:00
* gcc-wrapper: use the right dynamic linker when -m32 is used. * An attribute `stdenv_32bit' that returns a stdenv capable of building 32-bit binaries. * grub: build on x86_64-linux. svn path=/nixpkgs/trunk/; revision=12211
2008-06-29 17:13:02 +01: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
* Small cleanup. svn path=/nixpkgs/branches/stdenv-updates/; revision=15066
2009-04-15 14:28:17 +01:00
overrideGCC stdenv gcc43_multi
* gcc-wrapper: use the right dynamic linker when -m32 is used. * An attribute `stdenv_32bit' that returns a stdenv capable of building 32-bit binaries. * grub: build on x86_64-linux. svn path=/nixpkgs/trunk/; revision=12211
2008-06-29 17:13:02 +01:00
else
stdenv;
* bclr: shrink fixes.patch from 3.6 MB (!) to 11 KB by not including Autoconf/Automake generated code. svn path=/nixpkgs/trunk/; revision=22815
2010-07-29 20:56:16 +01:00
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
### BUILD SUPPORT
* Converting packages. This is the minimal Nix stdenv for building the ATerm library. svn path=/nixpkgs/trunk/; revision=459
2003-11-02 17:42:19 +00:00
Add an automated updater script and definitions for its use for WebKit svn path=/nixpkgs/trunk/; revision=16816
2009-08-23 23:10:08 +01:00
attrSetToDir = arg : import ../build-support/upstream-updater/attrset-to-dir.nix {
inherit writeTextFile stdenv lib;
theAttrSet = arg;
};
* Use all those new packages. svn path=/nixpkgs/trunk/; revision=545
2003-11-25 18:02:05 +00:00
adding postgis + script enabling postgis features Exporting builder.pl because it will be used in NixOS postgresql module svn path=/nixpkgs/trunk/; revision=21691
2010-05-09 21:38:16 +01:00
buildEnvScript = ../build-support/buildenv/builder.pl;
* Fork of build-env in the Nix distribution. This one supports ignoring collisions and selectively including directories. svn path=/nixpkgs/trunk/; revision=7160
2006-11-28 16:46:12 +00:00
buildEnv = import ../build-support/buildenv {
inherit stdenv perl;
};
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
Commited my experimental Visual C# build function. Currently, it should only be used by brave people svn path=/nixpkgs/trunk/; revision=22272
2010-06-15 12:16:35 +01:00
dotnetenv = import ../build-support/dotnetenv {
inherit stdenv;
dotnetfx = dotnetfx35;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
vsenv = callPackage ../build-support/vsenv {
Added my very experimental Visual Studio build stuff. You should be even more brave to use this svn path=/nixpkgs/trunk/; revision=22273
2010-06-15 12:32:19 +01:00
vs = vs90wrapper;
};
Add `fetchbzr', to retrieve remote Bazaar repositories. svn path=/nixpkgs/trunk/; revision=12924
2008-09-26 09:57:51 +01:00
fetchbzr = import ../build-support/fetchbzr {
inherit stdenv bazaar;
};
* Remove redundant parentheses. svn path=/nixpkgs/trunk/; revision=6758
2006-10-18 11:32:45 +01:00
fetchcvs = import ../build-support/fetchcvs {
* fetchcvs: cleanup, use nix-store --add-fixed like fetchurl/svn. Argument "url" renamed to "cvsRoot" (it's not a URL). svn path=/nixpkgs/trunk/; revision=10889
2008-02-28 22:36:37 +00:00
inherit stdenv cvs;
Added fetchcvs. svn path=/nixpkgs/trunk/; revision=5295
2006-05-11 13:36:16 +01:00
};
* Remove redundant parentheses. svn path=/nixpkgs/trunk/; revision=6758
2006-10-18 11:32:45 +01:00
fetchdarcs = import ../build-support/fetchdarcs {
* updated darcs to 1.0.5, added curl dependency * added an experimental fetchdarcs function, based on fetchsvn (there are no expressions yet that use this function) svn path=/nixpkgs/trunk/; revision=4615
2006-01-30 11:18:38 +00:00
inherit stdenv darcs nix;
};
* fetchgit and nix-prefetch-git svn path=/nixpkgs/trunk/; revision=16035
2009-06-24 13:48:01 +01:00
fetchgit = import ../build-support/fetchgit {
inherit stdenv git;
};
Adding fetchmtn, including fetchmtn and fetchgit in builder-defs, updating monotone-viz. Adding dadadodo. svn path=/nixpkgs/trunk/; revision=16207
2009-07-07 11:04:32 +01:00
fetchmtn = import ../build-support/fetchmtn {
inherit monotone stdenv;
cacheDB = getConfig ["fetchmtn" "cacheDB"] "";
defaultDBMirrors = getConfig ["fetchmtn" "defaultDBMirrors"] [];
};
* Remove redundant parentheses. svn path=/nixpkgs/trunk/; revision=6758
2006-10-18 11:32:45 +01:00
fetchsvn = import ../build-support/fetchsvn {
* fetchsvn: Nix already checks the hash, no need for the builder to do it. svn path=/nixpkgs/trunk/; revision=10896
2008-02-29 10:30:29 +00:00
inherit stdenv subversion openssh;
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
sshSupport = true;
};
Added hacky fetchsvn component which allows users to fetch code over svn+ssh svn path=/nixpkgs/trunk/; revision=11455
2008-04-02 14:28:55 +01:00
fetchsvnssh = import ../build-support/fetchsvnssh {
inherit stdenv subversion openssh expect;
sshSupport = true;
};
added: dnsmasq, uisp, fltk libixp_for_wmii, acerhk kernel module, reiserfsprogs, radeontools, msmtp, procmail, pstree, gxemul changed: umlutilities to also support building tunctl optionally (needing kernel header files) wmii updated and wmiimenu added svn path=/nixpkgs/trunk/; revision=9242
2007-09-03 13:10:57 +01:00
fetchhg = import ../build-support/fetchhg {
inherit stdenv mercurial nix;
};
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
# `fetchurl' downloads a file from the network.
fetchurl = import ../build-support/fetchurl {
inherit curl stdenv;
};
* GCC 4.0.0 added (though it's not used for anything yet). svn path=/nixpkgs/trunk/; revision=2878
2005-04-22 13:14:55 +01:00
* curl: build with OpenSSL (https) support by default. * Some fetchurl-related refactoring. The `realCurl' attribute is gone, `curl' is the real thing. To prevent an infinite recursion in `fetchurl' (because it depends on curl and building curl needs fetchurl), curl and its dependencies (openssl, zlib, perl) use `fetchurlBoot', which is the fetchurl used by the previous bootstrap phase (e.g. the statically linked version of curl for stdenv-linux). So as a result you can use https:// urls almost everywhere. There's also some hackery to prevent a different curl from being built in every stdenv-linux bootstrap phase (namely the stdenv.fetchurl attribute which allows fetchurl to be overriden everywhere). svn path=/nixpkgs/trunk/; revision=11905
2008-05-27 08:49:55 +01: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;
* Interface to support mirror:// in nix-prefetch-url. The function resolveMirrorURLs produces a file containing the URLs to which a mirror:// URL resolves. svn path=/nixpkgs/trunk/; revision=12410
2008-07-23 17:04:10 +01:00
resolveMirrorURLs = {url}: fetchurl {
showURLs = true;
inherit url;
};
Added desktop file generation function and desktop item for firefox svn path=/nixpkgs/trunk/; revision=15529
2009-05-10 13:03:53 +01:00
makeDesktopItem = import ../build-support/make-desktopitem {
inherit stdenv;
};
all-packages.nix: commented out package 'vice' error: getting status of `/usr/local/src/nix-pkgs-current/pkgs/misc/emulators/vice': No such file or directory svn path=/nixpkgs/trunk/; revision=15646
2009-05-18 14:53:01 +01:00
* makeInitrd, makeModulesClosure: moved from NixOS. * Use sh from klibc in the initrd. svn path=/nixpkgs/trunk/; revision=11154
2008-03-17 10:40:47 +00: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 17:35:47 +00:00
inherit stdenv perl cpio contents ubootChooser;
* makeInitrd, makeModulesClosure: moved from NixOS. * Use sh from klibc in the initrd. svn path=/nixpkgs/trunk/; revision=11154
2008-03-17 10:40:47 +00:00
};
* makeWrapper: option --run <CMD> to run a command from the wrapper. This is so that the Unison wrapper can be generated with makeWrapper. * Use makeWrapper as a buildInput everywhere. * Updated BitTorrent, cvs2svn. svn path=/nixpkgs/trunk/; revision=10213
2008-01-18 11:28:41 +00:00
makeWrapper = makeSetupHook ../build-support/make-wrapper/make-wrapper.sh;
* makeWrapper: new function that transparently takes care of creating a wrapper script. E.g. wrapProgram $out/bin/prog --set FOO bar will create a wrapper around "prog" so that the environment variable FOO is set to bar. The original program is renamed to $out/bin/.wrapped-prog. * Function makeSetupHook to convert a script into a setup hook which can be included in buildInputs. This makes it easier to use scripts like makeWrapper. * Added Bazaar, yet another distributed version management system. svn path=/nixpkgs/trunk/; revision=10211
2008-01-18 10:29:58 +00:00
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
makeModulesClosure = {kernel, rootModules, allowMissing ? false}:
all-packages.nix changes for all previous commits.. svn path=/nixpkgs/trunk/; revision=11276
2008-03-24 19:40:15 +00:00
import ../build-support/kernel/modules-closure.nix {
* addCoverageInstrumentation: factor out the code that keeps the build tree under $out into a separate stdenv adapter named keepBuildTree. * makeModulesClosure: support building an initrd for a kernel that has been compiled with coverage instrumentation. svn path=/nixpkgs/trunk/; revision=16916
2009-09-01 22:56:46 +01:00
inherit stdenv module_init_tools kernel nukeReferences
rootModules allowMissing;
all-packages.nix changes for all previous commits.. svn path=/nixpkgs/trunk/; revision=11276
2008-03-24 19:40:15 +00:00
};
* makeInitrd, makeModulesClosure: moved from NixOS. * Use sh from klibc in the initrd. svn path=/nixpkgs/trunk/; revision=11154
2008-03-17 10:40:47 +00:00
* Export the paths-from-graph.pl script. svn path=/nixpkgs/trunk/; revision=15865
2009-06-05 14:20:14 +01:00
pathsFromGraph = ../build-support/kernel/paths-from-graph.pl;
A helper to get the source some package is built from. svn path=/nixpkgs/trunk/; revision=12933
2008-10-01 16:57:22 +01:00
srcOnly = args: (import ../build-support/src-only) ({inherit stdenv; } // args);
* Move the substitution functions into stdenv (not merged yet). * If the environment variable buildCommand is set, then eval that instead of doing the build phases. This is used by the runCommand function in all-packages.nix to allow one-lines like foo = runCommand "foo" {} "mkdir $out; echo foo > $out/foo"; svn path=/nixpkgs/trunk/; revision=7298
2006-12-10 22:24:42 +00:00
substituteAll = import ../build-support/substitute/substitute-all.nix {
Removed references to setup-new-2.sh and setup-new.sh from all-packages.nix svn path=/nixpkgs/branches/stdenv-updates/; revision=9737
2007-11-17 14:34:34 +00:00
inherit stdenv;
* Utility: the generic substituter. It substitutes all occurences of `@var@' in the file `src', writing the result to $out, where `var' is any environment variable starting with a lowercase character. Example: genericSubstituter { src = ./file; foo = "bla"; shell = bash + "/bin/sh"; }; will replace `@foo@' with `bla' and `@shell@' with `/nix/store/...-bash-.../bin/sh'. svn path=/nixpkgs/trunk/; revision=6928
2006-11-02 22:44:32 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
nukeReferences = callPackage ../build-support/nuke-references/default.nix { };
* buildRPM: print out the RPMs in the image. svn path=/nixpkgs/trunk/; revision=11168
2008-03-17 17:29:07 +00:00
vmTools = import ../build-support/vm/default.nix {
inherit pkgs;
};
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
* Start moving the Nix expressions that support the build farm (e.g. making source tarballs, doing coverage analysis) to the Nixpkgs tree. This makes it easier to run build farm jobs locally since you don't need to check out the "release" tree separately. Also it means one less input to declare for build farm jobs. * Removed succeedOnFailure and separate logging of phases. Hydra doesn't need that. svn path=/nixpkgs/trunk/; revision=13388
2008-11-24 15:10:06 +00:00
releaseTools = import ../build-support/release/default.nix {
inherit pkgs;
};
removed mkDerivationByConfiguration, using composableDerivation instead qgis, vim_configurable both work now svn path=/nixpkgs/trunk/; revision=13661
2008-12-20 01:20:35 +00:00
composableDerivation = (import ../lib/composable-derivation.nix) {
inherit pkgs lib;
};
* Turn the nukeRefs() function into a separate program. svn path=/nixpkgs/trunk/; revision=6941
2006-11-03 13:33:24 +00: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 17:35:47 +00:00
platforms = import ./platforms.nix;
Porting changes from stdenv-updates into this branch. This comes from: svn diff ^/nixpkgs/trunk/@18255 ^/nixpkgs/branches/stdenv-updates/ > diff patch -p0 < diff and then adding into svn all files new from the patch. trunk@18255 comes from the last time I updated stdenv-updates from trunk. svn path=/nixpkgs/stdenv-updates2/; revision=18272
2009-11-08 00:32:12 +00:00
* Updates paths in all-packages-generic.fix. svn path=/nixpkgs/trunk/; revision=472
2003-11-03 18:21:30 +00: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 17:26:58 +01:00
acct = callPackage ../tools/system/acct { };
Add GNU Accounting Utilities. svn path=/nixpkgs/trunk/; revision=16981
2009-09-08 09:29:40 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
aefs = callPackage ../tools/filesystems/aefs { };
* Added AEFS. svn path=/nixpkgs/trunk/; revision=8549
2007-04-08 00:38:01 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
aircrackng = callPackage ../tools/networking/aircrack-ng { };
Adding aircrack-ng. svn path=/nixpkgs/trunk/; revision=13936
2009-02-01 21:21:12 +00:00
Adding asymptote graphic generation tool svn path=/nixpkgs/trunk/; revision=20158
2010-02-21 17:36:41 +00: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 17:26:58 +01:00
ec2apitools = callPackage ../tools/virtualization/amazon-ec2-api-tools { };
amazon ec2 api tools svn path=/nixpkgs/trunk/; revision=17975
2009-10-27 12:51:09 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ec2amitools = callPackage ../tools/virtualization/amazon-ec2-ami-tools { };
amazon ec2 api tools svn path=/nixpkgs/trunk/; revision=17975
2009-10-27 12:51:09 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
amule = callPackage ../tools/networking/p2p/amule { };
Added aMule svn path=/nixpkgs/trunk/; revision=9413
2007-10-06 16:59:35 +01:00
Added aria - metalink/http/ftp/bittorrent supporting downloader svn path=/nixpkgs/trunk/; revision=12175
2008-06-21 21:53:52 +01:00
aria = builderDefsPackage (import ../tools/networking/aria) {
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
Added aria - metalink/http/ftp/bittorrent supporting downloader svn path=/nixpkgs/trunk/; revision=12175
2008-06-21 21:53:52 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
aria2 = callPackage ../tools/networking/aria2 { };
* Added aria2, a download utility. svn path=/nixpkgs/trunk/; revision=21912
2010-05-20 12:11:24 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
at = callPackage ../tools/system/at { };
Add At, the classical Unix command scheduler. svn path=/nixpkgs/trunk/; revision=11434
2008-04-01 10:08:17 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
autogen = callPackage ../development/tools/misc/autogen { };
Add GNU AutoGen. svn path=/nixpkgs/trunk/; revision=17491
2009-09-29 10:01:40 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
autojump = callPackage ../tools/misc/autojump { };
Add Autojump, a smart replacement for `cd'. svn path=/nixpkgs/trunk/; revision=15738
2009-05-26 23:05:05 +01:00
Avahi: Make Qt4 support optional and configurable. svn path=/nixpkgs/trunk/; revision=10997
2008-03-06 16:42:34 +00:00
avahi =
let qt4Support = getConfig [ "avahi" "qt4Support" ] false;
in
A case study in transitive overrides. WebKit needs fresh glib. This means it needs a whole slice of system built against glib-2.22.. Added overrides are generic enough, though. So the same way can be used to override everything. I have failed (so far?) to add mkOverridable into stdenv, though. svn path=/nixpkgs/trunk/; revision=17661
2009-10-06 06:43:51 +01:00
makeOverridable (import ../development/libraries/avahi) {
* Clean up indentation (expanded tabs etc.). svn path=/nixpkgs/trunk/; revision=11150
2008-03-17 09:41:28 +00:00
inherit stdenv fetchurl pkgconfig libdaemon dbus perl perlXMLParser
Avahi 0.6.24. svn path=/nixpkgs/trunk/; revision=13626
2008-12-12 23:02:11 +00:00
expat gettext intltool lib;
* Clean up indentation (expanded tabs etc.). svn path=/nixpkgs/trunk/; revision=11150
2008-03-17 09:41:28 +00:00
inherit (gtkLibs) glib gtk;
inherit qt4Support;
qt4 = if qt4Support then qt4 else null;
Avahi: Make Qt4 support optional and configurable. svn path=/nixpkgs/trunk/; revision=10997
2008-03-06 16:42:34 +00:00
};
Add `avahi' package. svn path=/nixpkgs/trunk/; revision=10527
2008-02-06 19:36:12 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
axel = callPackage ../tools/networking/axel { };
add axel, a downloader with support for multiple connection for faster downloading svn path=/nixpkgs/trunk/; revision=9139
2007-08-16 20:50:59 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
azureus = callPackage ../tools/networking/p2p/azureus { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
bc = callPackage ../tools/misc/bc { };
Added bc :P svn path=/nixpkgs/trunk/; revision=4045
2005-10-10 01:55:07 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
bfr = callPackage ../tools/misc/bfr { };
bfr added (pipe buffer) svn path=/nixpkgs/trunk/; revision=12348
2008-07-11 21:27:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
bootchart = callPackage ../tools/system/bootchart { };
Adding the bootchart capture script. It worked for me, run standalone, not as init. I tried their website renderer, but it did not work for me. It may be shut down, because their last update is for 2006. Next steps: put it into nixos, and build the renderer (java!). svn path=/nixpkgs/trunk/; revision=18041
2009-10-29 23:15:10 +00:00
* Refactoring: move most filesystem utilities / FUSE filesystems to tools/filesystems. Previously they were all over the place. svn path=/nixpkgs/trunk/; revision=18809
2009-12-04 15:39:49 +00:00
btrfsProgs = builderDefsPackage (import ../tools/filesystems/btrfsprogs) {
inherit libuuid zlib acl;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
catdoc = callPackage ../tools/text/catdoc { };
Add catdoc svn path=/nixpkgs/trunk/; revision=21558
2010-05-03 04:45:40 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
eggdrop = callPackage ../tools/networking/eggdrop { };
added eggdrop, iftop svn path=/nixpkgs/trunk/; revision=17710
2009-10-08 08:01:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mcrl = callPackage ../tools/misc/mcrl { };
* added mcrl, mcrl2 and openmpi to all-packages.nix svn path=/nixpkgs/trunk/; revision=15874
2009-06-05 15:36:35 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mcrl2 = callPackage ../tools/misc/mcrl2 { };
* added mcrl, mcrl2 and openmpi to all-packages.nix svn path=/nixpkgs/trunk/; revision=15874
2009-06-05 15:36:35 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
syslogng = callPackage ../tools/misc/syslog-ng { };
Added syslog-ng (and the eventlog library that it depends on). svn path=/nixpkgs/trunk/; revision=13988
2009-02-05 16:50:45 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
asciidoc = callPackage ../tools/typesetting/asciidoc { };
Add AsciiDoc. svn path=/nixpkgs/trunk/; revision=11039
2008-03-10 15:57:14 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
autossh = callPackage ../tools/networking/autossh { };
added autossh 1.4b. svn path=/nixpkgs/trunk/; revision=22018
2010-05-27 20:43:57 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
bibtextools = callPackage ../tools/typesetting/bibtex-tools {
* More cleanup. Updated to the latest Stratego/XT 0.17. svn path=/nixpkgs/trunk/; revision=14610
2009-03-19 14:34:16 +00:00
inherit (strategoPackages016) strategoxt sdf;
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
bittorrent = callPackage ../tools/networking/p2p/bittorrent {
* Added wxGTK/wxPython 2.8. However this was quite pointless as Bittorrent is even more broken with wxPython 2.8. svn path=/nixpkgs/trunk/; revision=8812
2007-05-31 14:43:13 +01:00
wxPython = wxPython26;
* BitTorrent 5.0.3. * wxPython 2.6.3. svn path=/nixpkgs/trunk/; revision=7341
2006-12-13 20:30:09 +00:00
gui = true;
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
bittornado = callPackage ../tools/networking/p2p/bit-tornado { };
Added BitTornado, as BitTorrent doesn't support IPv6 svn path=/nixpkgs/trunk/; revision=8897
2007-06-20 00:38:01 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
blueman = callPackage ../tools/bluetooth/blueman {
* Added Blueman (a Bluetooth application). * Added obex-data-server and python-notify, needed by Blueman. svn path=/nixpkgs/trunk/; revision=22497
2010-07-06 15:54:22 +01:00
inherit (pythonPackages) notify;
inherit (gtkLibs) glib gtk;
};
* Removed selectVersion. There's no good reason to write `selectVersion ./foo "bar"' instead of `import ./foo/bar.nix'. * Replaced `with args' with formal function arguments in several packages. * Renamed several files to `default.nix'. As a general rule, version numbers should only be included in the filename when there is a reason to keep multiple versions of a package in Nixpkgs. Otherwise, it just makes it harder to update the package. svn path=/nixpkgs/trunk/; revision=18403
2009-11-18 09:39:59 +00:00
bmrsa = builderDefsPackage (import ../tools/security/bmrsa/11.nix) {
Starting migrating old builderDefs packages to builderDefsPackage style. svn path=/nixpkgs/trunk/; revision=13591
2008-12-04 21:01:26 +00:00
inherit unzip;
Added Shamir Secret Sharing Scheme and bmrsa. Fixed libgcrypt svn path=/nixpkgs/trunk/; revision=10928
2008-03-03 12:30:39 +00:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
bogofilter = callPackage ../tools/misc/bogofilter {
Add Bogofilter, a fast bayesian spam filter. svn path=/nixpkgs/trunk/; revision=10908
2008-03-02 18:35:04 +00: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 17:26:58 +01:00
bsdiff = callPackage ../tools/compression/bsdiff { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
bzip2 = callPackage ../tools/compression/bzip2 { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cabextract = callPackage ../tools/archivers/cabextract { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ccid = callPackage ../tools/security/ccid { };
Adding pcsclite with the opensource ccid usb drivers. This gives a daemon controlling the smartcard reader used to read the Spanish identity card. svn path=/nixpkgs/trunk/; revision=19319
2010-01-09 17:35:57 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ccrypt = callPackage ../tools/security/ccrypt { };
Committing Lluís Batlle's submissions from mailing list posting <45219fb00901110456i6f21db35tbd1894eaea2146ff@mail.gmail.com>: * nixpkgs-ccrypt-1.7-new.patch * nixpkgs-cmake-add-ccmake.patch * nixpkgs-cpufrequtils-005-new.patch * nixpkgs-dwm-5.1-fix.patch * nixpkgs-freeimage-3.11.0-new.patch * nixpkgs-proxychains-3.1-new.patch * nixpkgs-psi-to-0.12.patch * nixpkgs-skype-to-2.0.0.72.patch * nixpkgs-truecrypt-6.1a-fix.patch * nixpkgs-vxl-1.11.0-new.patch * nixpkgs-xkb-popular-esperanto-symbols.patch * nixpkgs-xorg-via-video-fix.patch svn path=/nixpkgs/trunk/; revision=13751
2009-01-12 21:12:07 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cdecl = callPackage ../development/tools/cdecl { };
Adding cdecl-2.5 svn path=/nixpkgs/trunk/; revision=13833
2009-01-24 21:01:27 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cdrdao = callPackage ../tools/cd-dvd/cdrdao { };
* Move dvd+rw-tools and cdrkit to tools/cd-dvd. * Added cdrdao. svn path=/nixpkgs/trunk/; revision=12426
2008-07-25 14:04:51 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cdrkit = callPackage ../tools/cd-dvd/cdrkit { };
* Move dvd+rw-tools and cdrkit to tools/cd-dvd. * Added cdrdao. svn path=/nixpkgs/trunk/; revision=12426
2008-07-25 14:04:51 +01:00
Adding cfdg - context-free design grammar svn path=/nixpkgs/trunk/; revision=20166
2010-02-22 10:46:49 +00: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 17:26:58 +01:00
checkinstall = callPackage ../tools/package-management/checkinstall { };
* Automatically build Debian packages using checkinstall, as suggested by Pjotr Prins a while back. This could also be used to generate RPMs for packages that don't have a spec-file. * Added checkinstall to Nixpkgs. However we don't use our own build yet because with it "make install" segfaults in a Debian VM, while the pre-built binary does work. svn path=/nixpkgs/trunk/; revision=13400
2008-11-25 02:20:41 +00:00
* Removed selectVersion. There's no good reason to write `selectVersion ./foo "bar"' instead of `import ./foo/bar.nix'. * Replaced `with args' with formal function arguments in several packages. * Renamed several files to `default.nix'. As a general rule, version numbers should only be included in the filename when there is a reason to keep multiple versions of a package in Nixpkgs. Otherwise, it just makes it harder to update the package. svn path=/nixpkgs/trunk/; revision=18403
2009-11-18 09:39:59 +00:00
cheetahTemplate = builderDefsPackage (import ../tools/text/cheetah-template/2.0.1.nix) {
Upgrade default to python version 2.5.x. svn path=/nixpkgs/trunk/; revision=12910
2008-09-24 09:50:32 +01:00
inherit makeWrapper python;
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
Added cheetah-template templating engine svn path=/nixpkgs/trunk/; revision=12053
2008-06-12 11:07:54 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
chkrootkit = callPackage ../tools/security/chkrootkit { };
add chkrootkit. It might need some tweaks to work properly. svn path=/nixpkgs/trunk/; revision=10141
2008-01-14 14:43:24 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cksfv = callPackage ../tools/networking/cksfv { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
convertlit = callPackage ../tools/text/convertlit { };
* Added convertlit, a tool for converting Microsoft Reader ebooks, plus its dependency libtommath. svn path=/nixpkgs/trunk/; revision=12606
2008-08-12 20:57:35 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
unifdef = callPackage ../development/tools/misc/unifdef { };
- Some Ruby interpreter bumped version - Kernel headers 2.6.18 added (XEN virtual images) - unifdef package added for kernel headers 2.6.18 - Python Zope and 4suite added - Trying bioconductor packages with R-lang (still failing) - Bumped gmp version - Added rq cluster runner - still requires extra gems (installs, but does not run) svn path=/nixpkgs/trunk/; revision=12766
2008-08-29 14:53:28 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
usb_modeswitch = callPackage ../development/tools/misc/usb-modeswitch { };
adding wvdial, wvstreams, usb_modeswitch svn path=/nixpkgs/trunk/; revision=21131
2010-04-16 16:56:28 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cloogppl = callPackage ../development/libraries/cloog-ppl { };
Add CLooG-PPL, an optional dependency of GCC 4.4. svn path=/nixpkgs/trunk/; revision=16422
2009-07-18 22:28:10 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
convmv = callPackage ../tools/misc/convmv { };
Add convmv svn path=/nixpkgs/trunk/; revision=22444
2010-07-03 09:06:01 +01:00
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
coreutils = callPackage (if stdenv ? isDietLibC
then ../tools/misc/coreutils-5
else ../tools/misc/coreutils)
* Fix static linking in gcc. * Use the coreutils in dietlibc. * Add objdump to the binutils static tarball. svn path=/nixpkgs/trunk/; revision=6879
2006-10-27 21:08:53 +01:00
{
Add cross Coreutils. svn path=/nixpkgs/trunk/; revision=21935
2010-05-21 14:46:54 +01:00
# TODO: Add ACL support for cross-Linux.
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
aclSupport = crossSystem == null && stdenv.isLinux;
Porting changes from stdenv-updates into this branch. This comes from: svn diff ^/nixpkgs/trunk/@18255 ^/nixpkgs/branches/stdenv-updates/ > diff patch -p0 < diff and then adding into svn all files new from the patch. trunk@18255 comes from the last time I updated stdenv-updates from trunk. svn path=/nixpkgs/stdenv-updates2/; revision=18272
2009-11-08 00:32:12 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cpio = callPackage ../tools/archivers/cpio { };
* Converting packages. This is the minimal Nix stdenv for building the ATerm library. svn path=/nixpkgs/trunk/; revision=459
2003-11-02 17:42:19 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cromfs = callPackage ../tools/archivers/cromfs { };
Added cromfs - patch by Lluis Batlle svn path=/nixpkgs/trunk/; revision=13700
2009-01-04 17:24:11 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cron = callPackage ../tools/system/cron { # see also fcron
* Added cron. svn path=/nixpkgs/trunk/; revision=7618
2007-01-10 15:44:58 +00:00
};
Add optional scp support to curl svn path=/nixpkgs/trunk/; revision=22976
2010-08-05 22:06:45 +01:00
curl = makeOverridable (import ../tools/networking/curl) rec {
* curl: build with OpenSSL (https) support by default. * Some fetchurl-related refactoring. The `realCurl' attribute is gone, `curl' is the real thing. To prevent an infinite recursion in `fetchurl' (because it depends on curl and building curl needs fetchurl), curl and its dependencies (openssl, zlib, perl) use `fetchurlBoot', which is the fetchurl used by the previous bootstrap phase (e.g. the statically linked version of curl for stdenv-linux). So as a result you can use https:// urls almost everywhere. There's also some hackery to prevent a different curl from being built in every stdenv-linux bootstrap phase (namely the stdenv.fetchurl attribute which allows fetchurl to be overriden everywhere). svn path=/nixpkgs/trunk/; revision=11905
2008-05-27 08:49:55 +01:00
fetchurl = fetchurlBoot;
Add optional scp support to curl svn path=/nixpkgs/trunk/; revision=22976
2010-08-05 22:06:45 +01:00
inherit stdenv zlib openssl libssh2;
Not using dependencies when building statically.. svn path=/nixpkgs/trunk/; revision=11995
2008-06-06 08:50:52 +01:00
zlibSupport = ! ((stdenv ? isDietLibC) || (stdenv ? isStatic));
Add optional scp support to curl svn path=/nixpkgs/trunk/; revision=22976
2010-08-05 22:06:45 +01:00
sslSupport = zlibSupport;
* CURL: build without scp support on Cygwin because libssh2 doesn't build. svn path=/nixpkgs/trunk/; revision=23142
2010-08-12 12:54:55 +01:00
scpSupport = zlibSupport && !stdenv.isSunOS && !stdenv.isCygwin;
* curl: build with OpenSSL (https) support by default. * Some fetchurl-related refactoring. The `realCurl' attribute is gone, `curl' is the real thing. To prevent an infinite recursion in `fetchurl' (because it depends on curl and building curl needs fetchurl), curl and its dependencies (openssl, zlib, perl) use `fetchurlBoot', which is the fetchurl used by the previous bootstrap phase (e.g. the statically linked version of curl for stdenv-linux). So as a result you can use https:// urls almost everywhere. There's also some hackery to prevent a different curl from being built in every stdenv-linux bootstrap phase (namely the stdenv.fetchurl attribute which allows fetchurl to be overriden everywhere). svn path=/nixpkgs/trunk/; revision=11905
2008-05-27 08:49:55 +01:00
};
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
curlftpfs = callPackage ../tools/filesystems/curlftpfs { };
Added curlftpfs which is for mounting ftp's with fuse. svn path=/nixpkgs/trunk/; revision=9520
2007-10-25 15:07:50 +01:00
Adding fetchmtn, including fetchmtn and fetchgit in builder-defs, updating monotone-viz. Adding dadadodo. svn path=/nixpkgs/trunk/; revision=16207
2009-07-07 11:04:32 +01: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 17:26:58 +01:00
dar = callPackage ../tools/archivers/dar { };
Adding dar (disk archiver with indexable archives) - patch by Lluis Batlle svn path=/nixpkgs/trunk/; revision=13695
2009-01-03 15:11:52 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
davfs2 = callPackage ../tools/filesystems/davfs2 {
* davfs2 updated to 1.4.5. * neon updated to 0.28.6. svn path=/nixpkgs/trunk/; revision=18841
2009-12-08 13:08:27 +00:00
neon = neon028;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dcraw = callPackage ../tools/graphics/dcraw { };
Adding dcraw. svn path=/nixpkgs/trunk/; revision=14904
2009-04-06 18:50:17 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
debootstrap = callPackage ../tools/misc/debootstrap { };
adding debootstrap (bootstrap debian in a chroot) svn path=/nixpkgs/trunk/; revision=17709
2009-10-08 01:54:31 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ddclient = callPackage ../tools/networking/ddclient { };
* ddclient svn path=/nixpkgs/trunk/; revision=17183
2009-09-16 12:53:09 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ddrescue = callPackage ../tools/system/ddrescue { };
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
desktop_file_utils = callPackage ../tools/misc/desktop-file-utils { };
Use $NIXPKGS_CONFIG to determine whether ghostscript has cups support. svn path=/nixpkgs/trunk/; revision=14275
2009-02-27 13:44:31 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dev86 = callPackage ../development/compilers/dev86 { };
Adding dev86 (I'll try to get virtualbox built) svn path=/nixpkgs/trunk/; revision=13844
2009-01-25 14:31:24 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
dnsmasq = callPackage ../tools/networking/dnsmasq {
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
# TODO i18n can be installed as well, implement it?
added: dnsmasq, uisp, fltk libixp_for_wmii, acerhk kernel module, reiserfsprogs, radeontools, msmtp, procmail, pstree, gxemul changed: umlutilities to also support building tunctl optionally (needing kernel header files) wmii updated and wmiimenu added svn path=/nixpkgs/trunk/; revision=9242
2007-09-03 13:10:57 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dhcp = callPackage ../tools/networking/dhcp { };
add findutilsStatic svn path=/nixpkgs/trunk/; revision=6250
2006-08-26 10:44:39 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dhcpcd = callPackage ../tools/networking/dhcpcd { };
* dhcpcd, another DHCP client (not tested). Hopefully it works better than dhclient in conjunction with wpa_supplicant. svn path=/nixpkgs/trunk/; revision=16411
2009-07-17 12:41:19 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
diffstat = callPackage ../tools/text/diffstat { };
Add diffstat. (by Vincent Ordy) svn path=/nixpkgs/trunk/; revision=11823
2008-05-14 08:58:32 +01:00
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
diffutils = callPackage ../tools/text/diffutils { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dirmngr = callPackage ../tools/security/dirmngr { };
Mass GnuPG upgrade gnupg tests fail. Will try to fix later. svn path=/nixpkgs/trunk/; revision=21884
2010-05-19 21:58:56 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
docbook2x = callPackage ../tools/typesetting/docbook2x {
* Drop the "perl" prefix from Perl attribute names. It's redundant now that Perl packages are in their own namespace (perlPackages.<pkg>). svn path=/nixpkgs/trunk/; revision=15176
2009-04-20 13:49:35 +01:00
inherit (perlPackages) XMLSAX XMLParser XMLNamespaceSupport;
some more x86_64 darwin changes svn path=/nixpkgs/trunk/; revision=18774
2009-12-02 22:19:49 +00:00
libiconv = if stdenv.isDarwin then libiconv else null;
Add docbook2x. svn path=/nixpkgs/trunk/; revision=11051
2008-03-11 09:34:17 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dosfstools = callPackage ../tools/filesystems/dosfstools { };
Added dosfstools svn path=/nixpkgs/trunk/; revision=10487
2008-02-04 04:41:55 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dotnetfx35 = callPackage ../development/libraries/dotnetfx35 { };
Commited my experimental Visual C# build function. Currently, it should only be used by brave people svn path=/nixpkgs/trunk/; revision=22272
2010-06-15 12:16:35 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
dropbear = callPackage ../tools/networking/dropbear {
Adding dropbear, a small implementation of ssh2 client and server. I made it statically build by default I had to fix the zlib static cross-build, because the native stripping corrupted the target static library. It is not the first time I see this. I add drobear to the cross-built packages for hydra. svn path=/nixpkgs/trunk/; revision=20518
2010-03-09 23:11:12 +00:00
enableStatic = true;
zlib = zlibStatic;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
duplicity = callPackage ../tools/backup/duplicity {
* Added `boto', a Python interface to AWS. * Add boto as a dependency to duplicity to support backups to Amazon S3. svn path=/nixpkgs/trunk/; revision=19913
2010-02-10 18:10:22 +00:00
inherit (pythonPackages) boto;
Add gnupg1 compatibility wrapper Gnupg1compat is symlinked gnupg2 with two additional symlinks: gpg->gpg2 and gpgv->gpgv2. Move original gnupg 1.x to gnupg1orig. Set default gnupg1 to gnupg1compat. svn path=/nixpkgs/trunk/; revision=21888
2010-05-19 21:59:20 +01:00
gnupg = gnupg1;
Adding 'duplicity', and its dependency 'librsync' svn path=/nixpkgs/trunk/; revision=19813
2010-02-04 13:42:41 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dvdplusrwtools = callPackage ../tools/cd-dvd/dvd+rw-tools { };
* Move dvd+rw-tools and cdrkit to tools/cd-dvd. * Added cdrdao. svn path=/nixpkgs/trunk/; revision=12426
2008-07-25 14:04:51 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
e2fsprogs = callPackage ../tools/filesystems/e2fsprogs { };
* Refactoring: move most filesystem utilities / FUSE filesystems to tools/filesystems. Previously they were all over the place. svn path=/nixpkgs/trunk/; revision=18809
2009-12-04 15:39:49 +00:00
Add ebook-tools-0.1.1 svn path=/nixpkgs/trunk/; revision=23189
2010-08-16 13:40:03 +01: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 17:26:58 +01:00
ecryptfs = callPackage ../tools/security/ecryptfs { };
Adding ecryptfs, and one of its dependencies: keyutils. (I have not tried whether they work) svn path=/nixpkgs/trunk/; revision=19645
2010-01-25 10:34:47 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
enblendenfuse = callPackage ../tools/graphics/enblend-enfuse { };
Adding enblend-fuse, libxmi and hugin. Maybe hugin doesn't run well enough still. svn path=/nixpkgs/trunk/; revision=14894
2009-04-05 22:41:38 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
enscript = callPackage ../tools/text/enscript { };
add grub svn path=/nixpkgs/trunk/; revision=3391
2005-07-21 12:26:51 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
eprover = callPackage ../tools/misc/eProver {
Removing tetex reference in E Prover svn path=/nixpkgs/trunk/; revision=11810
2008-05-10 10:19:50 +01:00
texLive = texLiveAggregationFun {
paths = [
texLive texLiveExtra
];
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
* added ethtool 6 svn path=/nixpkgs/trunk/; revision=17346
2009-09-22 09:37:41 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ethtool = callPackage ../tools/misc/ethtool { };
add man svn path=/nixpkgs/trunk/; revision=3669
2005-08-23 15:19:16 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
exif = callPackage ../tools/graphics/exif { };
Adding exiftags svn path=/nixpkgs/trunk/; revision=17748
2009-10-11 16:52:27 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
exiftags = callPackage ../tools/graphics/exiftags { };
* Added expect. svn path=/nixpkgs/trunk/; revision=10877
2008-02-27 15:48:53 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
expect = callPackage ../tools/misc/expect { };
added fcron svn path=/nixpkgs/trunk/; revision=13192
2008-11-04 21:40:39 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
fcron = callPackage ../tools/system/fcron { # see also cron
Add GNU fdisk. svn path=/nixpkgs/trunk/; revision=16626
2009-08-09 23:15:40 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
fdisk = callPackage ../tools/system/fdisk { };
adding figlet svn path=/nixpkgs/trunk/; revision=15316
2009-04-26 12:06:48 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
figlet = callPackage ../tools/misc/figlet { };
file = callPackage ../tools/misc/file { };
Added the package man-pages. svn path=/nixpkgs/trunk/; revision=6071
2006-08-08 01:09:27 +01:00
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
findutils =
if stdenv.isDarwin
then findutils4227
else callPackage ../tools/misc/findutils { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
findutils4227 = callPackage ../tools/misc/findutils/4.2.27.nix { };
* Oops, the bootstrap tools contained an impure gzip/gunzip. * To prevent this kind of thing, check that all tools are statically linked. * Use findutils 4.2.27, 4.2.28 doesn't build with dietlibc. svn path=/nixpkgs/trunk/; revision=6881
2006-10-27 23:50:58 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
finger_bsd = callPackage ../tools/networking/bsd-finger { };
finger client and daemon added svn path=/nixpkgs/trunk/; revision=10364
2008-01-28 19:51:14 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
fontforge = callPackage ../tools/misc/fontforge { };
* Use FontForge to give Wine better fonts. svn path=/nixpkgs/trunk/; revision=9181
2007-08-21 13:31:33 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
fontforgeX = callPackage ../tools/misc/fontforge {
* Drop pkgsOverriden. svn path=/nixpkgs/trunk/; revision=22823
2010-07-30 13:10:24 +01:00
withX11 = true;
* Purity fix in fontforge: don't look for /usr/include/libxml. svn path=/nixpkgs/trunk/; revision=11288
2008-03-26 12:57:30 +00:00
};
Added FontForge with X11 interface svn path=/nixpkgs/trunk/; revision=10918
2008-03-02 22:02:28 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dos2unix = callPackage ../tools/text/dos2unix { };
dos2unix and unix2dos provided by griswold svn path=/nixpkgs/trunk/; revision=19409
2010-01-13 21:09:55 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
unix2dos = callPackage ../tools/text/unix2dos { };
dos2unix and unix2dos provided by griswold svn path=/nixpkgs/trunk/; revision=19409
2010-01-13 21:09:55 +00:00
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
gawk = callPackage ../tools/text/gawk { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gdmap = callPackage ../tools/system/gdmap {
* ltrace: updated to 0.5.3. * libdbi / libdbi-drivers: updated to 0.8.3, and make it compile with SQLite. * qemu-image: fix the URL. * gdmap: make it build again (requires an older GTK+). * rlwrap: updated to 0.37. * smbfs-fuse -> fusesmb to match the upstream name. * x11vnc: updated to 0.9.10. * clearlyU: fix the URL. * Various packages: follow the coding conventions. svn path=/nixpkgs/trunk/; revision=22814
2010-07-29 19:55:16 +01:00
inherit (gtkLibs216) gtk;
Added gdmap, changed builder-defs to use derivation attribute on propagatedBuildInputs, manually fixed Xorg expression problem for Compiz, various fixes. svn path=/nixpkgs/trunk/; revision=9812
2007-12-01 16:20:23 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
genext2fs = callPackage ../tools/filesystems/genext2fs { };
* Refactoring: move most filesystem utilities / FUSE filesystems to tools/filesystems. Previously they were all over the place. svn path=/nixpkgs/trunk/; revision=18809
2009-12-04 15:39:49 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gengetopt = callPackage ../development/tools/misc/gengetopt { };
Add GNU Gengetopt. svn path=/nixpkgs/trunk/; revision=19618
2010-01-22 17:00:44 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
getopt = callPackage ../tools/misc/getopt { };
* Added JDiskReport 1.2.3 (with a wrapper script `jdiskreport' to start it). svn path=/nixpkgs/trunk/; revision=4031
2005-10-08 00:02:58 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gftp = callPackage ../tools/networking/gftp {
* More cleanup. svn path=/nixpkgs/trunk/; revision=22795
2010-07-28 16:35:01 +01:00
inherit (gtkLibs) gtk;
Added: * dmenu * gftp * micropolis * byacc as a build-time dependency for micropolis contributed by baldo <baldo@quimby.lan> svn path=/nixpkgs/trunk/; revision=12526
2008-08-06 21:39:01 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gifsicle = callPackage ../tools/graphics/gifsicle { };
added gifscile (creating and reading gif animations) svn path=/nixpkgs/trunk/; revision=12176
2008-06-22 03:07:53 +01:00
* Refactoring: move most filesystem utilities / FUSE filesystems to tools/filesystems. Previously they were all over the place. svn path=/nixpkgs/trunk/; revision=18809
2009-12-04 15:39:49 +00:00
glusterfs = builderDefsPackage ../tools/filesystems/glusterfs {
Adding GlusterFS - a distributed storage system svn path=/nixpkgs/trunk/; revision=16896
2009-08-31 10:52:01 +01:00
inherit fuse;
bison = bison24;
flex = flex2535;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
glxinfo = callPackage ../tools/graphics/glxinfo { };
* Added glxinfo/glxgears. svn path=/nixpkgs/trunk/; revision=8593
2007-04-18 15:21:24 +01:00
Adding gnokii svn path=/nixpkgs/trunk/; revision=15916
2009-06-10 10:45:03 +01:00
gnokii = builderDefsPackage (import ../tools/misc/gnokii) {
Fixing Gnokii build svn path=/nixpkgs/trunk/; revision=22160
2010-06-05 22:14:41 +01:00
inherit intltool perl gettext libusb pkgconfig;
inherit (gtkLibs) glib;
Adding gnokii svn path=/nixpkgs/trunk/; revision=15916
2009-06-10 10:45:03 +01:00
};
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
gnugrep = callPackage ../tools/text/gnugrep { };
* Converted more packages. * Moved fetchurl, aterm. svn path=/nixpkgs/trunk/; revision=460
2003-11-02 18:14:24 +00:00
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
gnupatch = callPackage ../tools/text/gnupatch { };
* User-Mode Linux and GNU Patch. svn path=/nixpkgs/trunk/; revision=779
2004-02-13 14:42:28 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gnupg1orig = callPackage ../tools/security/gnupg1 {
pkgs/top-level/all-packages.nix: prefer makeOverridable over getPkgConfig to customize GNU Privacy Guard Changed 'gnupg' and 'gnupg2' expressions to allow for argument overriding instead of relying on getPkgConfig. svn path=/nixpkgs/trunk/; revision=21862
2010-05-19 13:25:45 +01:00
ideaSupport = false;
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gnupg1compat = callPackage ../tools/security/gnupg1compat { };
Add gnupg1 compatibility wrapper Gnupg1compat is symlinked gnupg2 with two additional symlinks: gpg->gpg2 and gpgv->gpgv2. Move original gnupg 1.x to gnupg1orig. Set default gnupg1 to gnupg1compat. svn path=/nixpkgs/trunk/; revision=21888
2010-05-19 21:59:20 +01: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 17:26:58 +01:00
gnupg = callPackage ../tools/security/gnupg { };
gnupg2 added svn path=/nixpkgs/trunk/; revision=10346
2008-01-28 19:45:57 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gnuplot = callPackage ../tools/graphics/gnuplot {
Updated Gnuplot to version 4.2.5. * Merged 'gnuplot' and 'gnuplotX' attributes into one that uses (getPkgConfig "gnuplot" "x11" false) to determine whether X11 support is desired or not. * Added Emacs as a build-time dependency to ensure that Gnuplot's lisp code is installed, too. * Added optional support for the wxt terminal by means of (getPkgConfig "gnuplot" "wxGtk" false). * Removed the '-nix' suffix to the package name. The Gnuplot license requires a vendor-specific version suffix only in case of modified binary distributions. That is not the case here. svn path=/nixpkgs/trunk/; revision=16992
2009-09-09 10:36:03 +01:00
inherit (gtkLibs) pango;
* More cleanup. svn path=/nixpkgs/trunk/; revision=22795
2010-07-28 16:35:01 +01:00
texLive = null;
lua = null;
Added gnuplotX - gnuplot with X11 on. svn path=/nixpkgs/trunk/; revision=9047
2007-08-04 16:12:14 +01:00
};
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
gnused = callPackage ../tools/text/gnused { };
* Converting packages. This is the minimal Nix stdenv for building the ATerm library. svn path=/nixpkgs/trunk/; revision=459
2003-11-02 17:42:19 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gnused_4_2 = callPackage ../tools/text/gnused/4.2.nix { };
GNU sed 4.2. svn path=/nixpkgs/trunk/; revision=15418
2009-04-30 20:36:26 +01:00
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
gnutar = callPackage ../tools/archivers/gnutar { };
* Converted more packages. * Moved fetchurl, aterm. svn path=/nixpkgs/trunk/; revision=460
2003-11-02 18:14:24 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gnuvd = callPackage ../tools/misc/gnuvd { };
* added gnuvd, dutch dictionary application svn path=/nixpkgs/trunk/; revision=17177
2009-09-16 09:36:05 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
graphviz = callPackage ../tools/graphics/graphviz {
* Graphviz updated to 2.20.2. Now built with fontconfig, gd and pango support. * New function makeFontsConf to generate a fontconfig configuration file. Moved from NixOS. * dot2pdf: use makeFontsConf to generate a fonts.conf containing just the Ghostscript fonts (see NIXPKGS-29). * dot2pdf: generate PDF directly, don't go through PS. Note that this and using fontconfig changes the interpretation of "fontname" attributes in dot graphs. svn path=/nixpkgs/trunk/; revision=12251
2008-07-03 15:27:19 +01:00
inherit (gtkLibs) pango;
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
};
pkgs/top-level/all-packages.nix: stripped trailing whitespace svn path=/nixpkgs/trunk/; revision=22734
2010-07-26 14:41:09 +01:00
/* Readded by Michael Raskin. There are programs in the wild
Readding old Graphviz: I need it for some graph program that relies on its way of grid snapping. svn path=/nixpkgs/trunk/; revision=22483
2010-07-05 20:04:33 +01:00
* that do want 2.0 but not 2.22. Please give a day's notice for
* objections before removal.
*/
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
graphviz_2_0 = callPackage ../tools/graphics/graphviz/2.0.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 17:26:58 +01:00
inherit (gtkLibs) pango; };
Readding old Graphviz: I need it for some graph program that relies on its way of grid snapping. svn path=/nixpkgs/trunk/; revision=22483
2010-07-05 20:04:33 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
groff = callPackage ../tools/text/groff {
* groff: don't build with ghostscript as a dependency by default. svn path=/nixpkgs/branches/stdenv-updates/; revision=14064
2009-02-12 22:33:17 +00:00
ghostscript = null;
add groff, needed for dhcp svn path=/nixpkgs/trunk/; revision=3651
2005-08-21 14:59:04 +01:00
};
* gcc-wrapper: use the right dynamic linker when -m32 is used. * An attribute `stdenv_32bit' that returns a stdenv capable of building 32-bit binaries. * grub: build on x86_64-linux. svn path=/nixpkgs/trunk/; revision=12211
2008-06-29 17:13:02 +01:00
grub = import ../tools/misc/grub {
inherit fetchurl autoconf automake;
stdenv = stdenv_32bit;
Enabling by default the grub support for buggy BIOSes on CD boot. Two of two, raskin and me, voted for this change. svn path=/nixpkgs/trunk/; revision=16361
2009-07-14 19:23:53 +01:00
buggyBiosCDSupport = (getConfig ["grub" "buggyBiosCDSupport"] true);
* gcc-wrapper: use the right dynamic linker when -m32 is used. * An attribute `stdenv_32bit' that returns a stdenv capable of building 32-bit binaries. * grub: build on x86_64-linux. svn path=/nixpkgs/trunk/; revision=12211
2008-06-29 17:13:02 +01:00
};
* Added GNU enscript. svn path=/nixpkgs/trunk/; revision=1040
2004-06-03 18:16:16 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
grub2 = callPackage ../tools/misc/grub/1.9x.nix { };
Add GNU GRUB 1.97~beta3 (aka. "GRUB 2"). svn path=/nixpkgs/trunk/; revision=17636
2009-10-04 22:39:34 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gssdp = callPackage ../development/libraries/gssdp {
* gcc-wrapper: use the right dynamic linker when -m32 is used. * An attribute `stdenv_32bit' that returns a stdenv capable of building 32-bit binaries. * grub: build on x86_64-linux. svn path=/nixpkgs/trunk/; revision=12211
2008-06-29 17:13:02 +01:00
inherit (gnome) libsoup;
};
add gssdp and gupnp here too svn path=/nixpkgs/trunk/; revision=12152
2008-06-18 20:40:56 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gt5 = callPackage ../tools/system/gt5 { };
Adding 'gt5', a diff-capable 'du' browser svn path=/nixpkgs/trunk/; revision=20236
2010-02-24 19:06:25 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gtkgnutella = callPackage ../tools/networking/p2p/gtk-gnutella {
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
inherit (gtkLibs) glib gtk;
};
Build xpf with python enabled libxml2 svn path=/nixpkgs/trunk/; revision=3229
2005-06-20 21:35:07 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gupnp = callPackage ../development/libraries/gupnp {
* gcc-wrapper: use the right dynamic linker when -m32 is used. * An attribute `stdenv_32bit' that returns a stdenv capable of building 32-bit binaries. * grub: build on x86_64-linux. svn path=/nixpkgs/trunk/; revision=12211
2008-06-29 17:13:02 +01:00
inherit (gnome) libsoup;
};
add gssdp and gupnp here too svn path=/nixpkgs/trunk/; revision=12152
2008-06-18 20:40:56 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gupnptools = callPackage ../tools/networking/gupnp-tools {
* gcc-wrapper: use the right dynamic linker when -m32 is used. * An attribute `stdenv_32bit' that returns a stdenv capable of building 32-bit binaries. * grub: build on x86_64-linux. svn path=/nixpkgs/trunk/; revision=12211
2008-06-29 17:13:02 +01:00
inherit (gtkLibs) gtk glib;
inherit (gnome) libsoup libglade gnomeicontheme;
add gupnp-tools. I can't actually run them, since there seems to be some issue with fontconfig that has not been configured correctly and i don't know why svn path=/nixpkgs/trunk/; revision=12154
2008-06-18 23:34:49 +01:00
};
Adding GVPE - a protected virtual multinode ethernet svn path=/nixpkgs/trunk/; revision=16913
2009-09-01 21:12:01 +01:00
gvpe = builderDefsPackage ../tools/networking/gvpe {
Fix /sbin/ reference. On Linux just replace it with an "ip link" reference svn path=/nixpkgs/trunk/; revision=16918
2009-09-01 23:42:05 +01:00
inherit openssl gmp nettools iproute;
Adding GVPE - a protected virtual multinode ethernet svn path=/nixpkgs/trunk/; revision=16913
2009-09-01 21:12:01 +01:00
};
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
gzip = callPackage ../tools/compression/gzip { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pigz = callPackage ../tools/compression/pigz { };
pigz: an implementation of gzip that can take advantage of multi-core CPUs Initial version. svn path=/nixpkgs/trunk/; revision=17707
2009-10-07 21:18:11 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
halibut = callPackage ../tools/typesetting/halibut { };
Adding the halibut typesetting system. svn path=/nixpkgs/trunk/; revision=14759
2009-03-29 21:32:22 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
hddtemp = callPackage ../tools/misc/hddtemp { };
hddtemp (tool to get harddisk temperatures) added and unfinished qgis expression (in case someone else want's to continue working on it) svn path=/nixpkgs/trunk/; revision=9903
2007-12-10 22:36:52 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
hdf5 = callPackage ../tools/misc/hdf5 { };
HDF5 1.8.5 svn path=/nixpkgs/trunk/; revision=22861
2010-08-02 09:58:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
hevea = callPackage ../tools/typesetting/hevea { };
Added the first release of xpf, Xml Pipes and Filters. svn path=/nixpkgs/trunk/; revision=1308
2004-08-20 23:06:36 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
highlight = callPackage ../tools/text/highlight { };
Added ViewMTN and dependency; currently ViewMTN has to be manually symlinked in corresponding directory. svn path=/nixpkgs/trunk/; revision=12060
2008-06-12 16:59:59 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
host = callPackage ../tools/networking/host { };
Add `host', a DNS query utility. svn path=/nixpkgs/trunk/; revision=13459
2008-11-27 13:54:49 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
httpfs2 = callPackage ../tools/filesystems/httpfs { };
Add HTTPFS2, for Linux. svn path=/nixpkgs/trunk/; revision=22308
2010-06-17 13:44:40 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
iasl = callPackage ../development/compilers/iasl { };
Fixing commits I did, which didn't follow well the writing rules. svn path=/nixpkgs/trunk/; revision=13868
2009-01-25 21:03:07 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
idutils = callPackage ../tools/misc/idutils { };
Add GNU Idutils, a text searching utility. svn path=/nixpkgs/trunk/; revision=11300
2008-03-27 11:09:40 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
iftop = callPackage ../tools/networking/iftop { };
added eggdrop, iftop svn path=/nixpkgs/trunk/; revision=17710
2009-10-08 08:01:55 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
imapsync = callPackage ../tools/networking/imapsync {
Adding imapsync, with the two needed perl packages. svn path=/nixpkgs/trunk/; revision=15967
2009-06-15 19:37:42 +01:00
inherit (perlPackages) MailIMAPClient;
Add GNU Idutils, a text searching utility. svn path=/nixpkgs/trunk/; revision=11300
2008-03-27 11:09:40 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
inetutils = callPackage ../tools/networking/inetutils { };
Add GNU Inetutils. svn path=/nixpkgs/trunk/; revision=10817
2008-02-21 18:58:11 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
iodine = callPackage ../tools/networking/iodine { };
Add iodine-0.4.1 svn path=/nixpkgs/trunk/; revision=11824
2008-05-14 09:01:03 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
iperf = callPackage ../tools/networking/iperf { };
added iperf (a tool to measure network bandwidth) svn path=/nixpkgs/trunk/; revision=14564
2009-03-16 18:39:04 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
ipmitool = callPackage ../tools/system/ipmitool {
pkgs/top-level/all-packages.nix: prefer makeOverridable over getPkgConfig to customize ipmitool Changed 'ipmitool' expression to allow for argument overriding instead of relying on getPkgConfig. svn path=/nixpkgs/trunk/; revision=21863
2010-05-19 13:25:48 +01:00
static = false;
pkgs/tools/system/ipmitool: command-line interface to IPMI-enabled devices Initial version 1.8.9. svn path=/nixpkgs/trunk/; revision=19542
2010-01-19 15:58:19 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jdiskreport = callPackage ../tools/misc/jdiskreport { };
- add a whole bunch of packages which were added today already (but also list them here) - enable OOo2 build svn path=/nixpkgs/trunk/; revision=4149
2005-10-26 22:10:31 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jfsrec = callPackage ../tools/filesystems/jfsrec { };
* Refactoring: move most filesystem utilities / FUSE filesystems to tools/filesystems. Previously they were all over the place. svn path=/nixpkgs/trunk/; revision=18809
2009-12-04 15:39:49 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jfsutils = callPackage ../tools/filesystems/jfsutils { };
* Refactoring: move most filesystem utilities / FUSE filesystems to tools/filesystems. Previously they were all over the place. svn path=/nixpkgs/trunk/; revision=18809
2009-12-04 15:39:49 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jhead = callPackage ../tools/graphics/jhead { };
Adding jhead svn path=/nixpkgs/trunk/; revision=17747
2009-10-11 16:52:14 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jing = callPackage ../tools/text/xml/jing { };
* Removed MythTV from cache * Make the jing library available svn path=/nixpkgs/trunk/; revision=4122
2005-10-24 15:01:08 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jing_tools = callPackage ../tools/text/xml/jing/jing-script.nix { };
Added jing package (RELAX NG validation) and jing-tools for invoking the Java application svn path=/nixpkgs/trunk/; revision=1508
2004-09-26 14:03:59 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
jnettop = callPackage ../tools/networking/jnettop {
Add Jnettop, a network traffic visualizer. svn path=/nixpkgs/trunk/; revision=13564
2008-12-03 14:22:55 +00: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 17:26:58 +01:00
jwhois = callPackage ../tools/networking/jwhois { };
* Added jwhois, the GNU whois client. svn path=/nixpkgs/trunk/; revision=9211
2007-08-28 15:45:00 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
keychain = callPackage ../tools/misc/keychain { };
added keychain, a gentoo tool to start gnupg and ssh daemon writing pids to a file so that you can share them easily on different shells svn path=/nixpkgs/trunk/; revision=11693
2008-04-23 11:51:23 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
kismet = callPackage ../applications/networking/sniffers/kismet { };
Adding kismet. svn path=/nixpkgs/trunk/; revision=13938
2009-02-01 21:21:27 +00:00
* Remove a redundant version of ktorrent (it's already in kde/extra-gear). svn path=/nixpkgs/trunk/; revision=21876
2010-05-19 14:57:20 +01:00
ktorrent = kde4.ktorrent;
* Added ktorrent. To use, add your ~/.nix-profile to the KDEDIRS environment variable and rerun kbuildsycoca. (Otherwise ktorrent will work, but it won't be able to find its plugins.) svn path=/nixpkgs/trunk/; revision=9081
2007-08-09 17:55:14 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
less = callPackage ../tools/misc/less { };
* Trang (tool for converting to and from RelaxNG schemas). svn path=/nixpkgs/trunk/; revision=5579
2006-07-04 20:17:34 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
most = callPackage ../tools/misc/most { };
pkgs/tools/misc/most: added version 5.0.0 Build instructions courtesy of Tim Horton <tmhorton@gmail.com>. svn path=/nixpkgs/trunk/; revision=21452
2010-04-30 10:21:18 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lftp = callPackage ../tools/networking/lftp { };
Added lftp ftp client. svn path=/nixpkgs/trunk/; revision=9042
2007-08-04 13:41:00 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libtorrent = callPackage ../tools/networking/p2p/libtorrent { };
Added libtorrent a bittorent library written in C++ for *nix and rtorrent a ncurses client for libtorrent. svn path=/nixpkgs/trunk/; revision=10842
2008-02-23 12:11:27 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
logrotate = callPackage ../tools/system/logrotate { };
Adding the logrotate I found in the freebsd ports. I think that is what debian, fedora and freebsd call 'logrotate'. svn path=/nixpkgs/trunk/; revision=21437
2010-04-29 18:55:06 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lout = callPackage ../tools/typesetting/lout { };
Add Lout, a document layout system based on a purely functional language. svn path=/nixpkgs/trunk/; revision=10634
2008-02-12 09:58:57 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lrzip = callPackage ../tools/compression/lrzip { };
Adding lrzip and rzip. svn path=/nixpkgs/trunk/; revision=14581
2009-03-17 21:17:51 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lsh = callPackage ../tools/networking/lsh { };
Adding lzop and updating lzo. svn path=/nixpkgs/trunk/; revision=14749
2009-03-28 19:28:59 +00:00
* Removed the lzma package - it's superseded by xz. svn path=/nixpkgs/branches/stdenv-updates/; revision=19027
2009-12-18 11:25:56 +00:00
lzma = xz;
xlock: fixed build and updated to version 5.24 svn path=/nixpkgs/trunk/; revision=17356
2009-09-22 21:16:38 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xz = callPackage ../tools/compression/xz { };
* Added lzma, a compression program that compresses better than bzip2. svn path=/nixpkgs/trunk/; revision=10513
2008-02-06 13:52:41 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lzop = callPackage ../tools/compression/lzop { };
Add GNU lsh, a GPL'd implementation of SSH, and `liboop', and event loop library. svn path=/nixpkgs/trunk/; revision=10637
2008-02-12 10:51:44 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mailutils = callPackage ../tools/networking/mailutils { };
Add GNU Mailutils 2.1. svn path=/nixpkgs/trunk/; revision=17041
2009-09-11 10:38:25 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
man = callPackage ../tools/misc/man { };
* A more pure man implementation. svn path=/nixpkgs/trunk/; revision=10547
2008-02-07 14:39:07 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
man_db = callPackage ../tools/misc/man-db { };
* Added cabextract. Might be useful for adding Visual C++. svn path=/nixpkgs/trunk/; revision=5368
2006-06-01 22:25:40 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
memtest86 = callPackage ../tools/misc/memtest86 { };
* Added Memtest86+. svn path=/nixpkgs/trunk/; revision=10059
2008-01-03 15:14:37 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mc = callPackage ../tools/misc/mc { };
Added midnight commander package svn path=/nixpkgs/trunk/; revision=10256
2008-01-23 09:57:11 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mcabber = callPackage ../applications/networking/instant-messengers/mcabber { };
Adding mcabber console jabber client - patch by Lluis Batlle svn path=/nixpkgs/trunk/; revision=13698
2009-01-04 17:11:38 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mcron = callPackage ../tools/system/mcron { };
Add GNU mcron, a `cron' implementation in Guile Scheme. svn path=/nixpkgs/trunk/; revision=14870
2009-04-03 19:46:26 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
mdbtools = callPackage ../tools/misc/mdbtools {
Added MDBtools svn path=/nixpkgs/trunk/; revision=11811
2008-05-11 10:45:26 +01:00
flex = flex2535;
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
Added MDBtools svn path=/nixpkgs/trunk/; revision=11811
2008-05-11 10:45:26 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
miniupnpd = callPackage ../tools/networking/miniupnpd { };
* Added miniupnpd, an implementation of the UPnP Internet Gateway Device (IGD) specification. * Updated iptables to 1.4.8. svn path=/nixpkgs/trunk/; revision=21929
2010-05-20 23:11:44 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mjpegtools = callPackage ../tools/video/mjpegtools { };
* Converted Mozilla Firebird. svn path=/nixpkgs/trunk/; revision=491
2003-11-07 11:18:47 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mkisofs = callPackage ../tools/cd-dvd/mkisofs { };
Add GNU mkisofs. svn path=/nixpkgs/trunk/; revision=19603
2010-01-21 16:53:16 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mktemp = callPackage ../tools/security/mktemp { };
* Mac needs Unzip 5.52. svn path=/nixpkgs/trunk/; revision=2434
2005-03-21 14:48:48 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mldonkey = callPackage ../applications/networking/p2p/mldonkey { };
Adding MLDonkey multiprotocol data distribution client - patch by Lluis Batlle svn path=/nixpkgs/trunk/; revision=13702
2009-01-04 17:35:11 +00:00
Adding monit monitoring tool; in the course of action creating a script to auto-prepare basic autoupdate layout svn path=/nixpkgs/trunk/; revision=16863
2009-08-26 17:22:20 +01:00
monit = builderDefsPackage ../tools/system/monit {
flex = flex2535;
bison = bison24;
inherit 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 17:26:58 +01:00
mpage = callPackage ../tools/text/mpage { };
Add Mpage, a tool to print multiple pages per sheet on a PostScript printer. svn path=/nixpkgs/trunk/; revision=11572
2008-04-11 14:22:35 +01:00
* Removed selectVersion. There's no good reason to write `selectVersion ./foo "bar"' instead of `import ./foo/bar.nix'. * Replaced `with args' with formal function arguments in several packages. * Renamed several files to `default.nix'. As a general rule, version numbers should only be included in the filename when there is a reason to keep multiple versions of a package in Nixpkgs. Otherwise, it just makes it harder to update the package. svn path=/nixpkgs/trunk/; revision=18403
2009-11-18 09:39:59 +00:00
msf = builderDefsPackage (import ../tools/security/metasploit/3.1.nix) {
all-packages.nix changes for all the previous commits svn path=/nixpkgs/trunk/; revision=11564
2008-04-11 10:32:27 +01: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 17:26:58 +01:00
mssys = callPackage ../tools/misc/mssys { };
* Added ms-sys, a program for writing Microsoft compatible boot records. svn path=/nixpkgs/trunk/; revision=10414
2008-01-30 17:08:38 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mtdutils = callPackage ../tools/filesystems/mtdutils { };
Adding mtdutils svn path=/nixpkgs/trunk/; revision=21436
2010-04-29 18:54:51 +01:00
* Added mtools. svn path=/nixpkgs/trunk/; revision=23014
2010-08-06 22:36:54 +01:00
mtools = callPackage ../tools/filesystems/mtools { };
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01: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 17:26:58 +01:00
multitrandata = callPackage ../tools/text/multitran/data { };
Adding multitran. I added a note in the 'data' expression, regarding a locale that should be added into the system. svn path=/nixpkgs/trunk/; revision=14582
2009-03-17 21:49:39 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libbtree = callPackage ../tools/text/multitran/libbtree { };
Adding multitran. I added a note in the 'data' expression, regarding a locale that should be added into the system. svn path=/nixpkgs/trunk/; revision=14582
2009-03-17 21:49:39 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libmtsupport = callPackage ../tools/text/multitran/libmtsupport { };
Adding multitran. I added a note in the 'data' expression, regarding a locale that should be added into the system. svn path=/nixpkgs/trunk/; revision=14582
2009-03-17 21:49:39 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libfacet = callPackage ../tools/text/multitran/libfacet { };
Adding multitran. I added a note in the 'data' expression, regarding a locale that should be added into the system. svn path=/nixpkgs/trunk/; revision=14582
2009-03-17 21:49:39 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libmtquery = callPackage ../tools/text/multitran/libmtquery { };
Adding multitran. I added a note in the 'data' expression, regarding a locale that should be added into the system. svn path=/nixpkgs/trunk/; revision=14582
2009-03-17 21:49:39 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mtutils = callPackage ../tools/text/multitran/mtutils { };
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01:00
});
Adding multitran. I added a note in the 'data' expression, regarding a locale that should be added into the system. svn path=/nixpkgs/trunk/; revision=14582
2009-03-17 21:49:39 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
muscleframework = callPackage ../tools/security/muscleframework { };
Adding more muscle programs and libraries. svn path=/nixpkgs/trunk/; revision=19320
2010-01-09 18:06:37 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
muscletool = callPackage ../tools/security/muscletool { };
Adding more muscle programs and libraries. svn path=/nixpkgs/trunk/; revision=19320
2010-01-09 18:06:37 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mysql2pgsql = callPackage ../tools/misc/mysql2pgsql { };
added mysql2pgsql (mysql dump to postrges sql converter) script svn path=/nixpkgs/trunk/; revision=11943
2008-05-31 23:49:00 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
namazu = callPackage ../tools/text/namazu { };
Add Namazu, a full-text search engine. svn path=/nixpkgs/trunk/; revision=13655
2008-12-17 17:09:29 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
nbd = callPackage ../tools/networking/nbd {
* nbd requires a static glib. Since it's the only package that does so, don't build the default glib statically but pass a custom glib to nbd. svn path=/nixpkgs/branches/x-updates/; revision=22658
2010-07-19 09:44:32 +01:00
glib = gtkLibs.glib.override {
stdenv = makeStaticBinaries stdenv;
Network Block Device (nbd): initial version 2.9.13 svn path=/nixpkgs/trunk/; revision=17414
2009-09-25 03:09:43 +01:00
};
Added nc6, updated xkeyboard-config svn path=/nixpkgs/trunk/; revision=10469
2008-02-03 08:53:47 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
nc6 = callPackage ../tools/networking/nc6 { };
Added ncat - for IPv6 support. svn path=/nixpkgs/trunk/; revision=8964
2007-07-09 08:23:16 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ncat = callPackage ../tools/networking/ncat { };
* added ncftp svn path=/nixpkgs/trunk/; revision=17214
2009-09-17 08:31:34 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ncftp = callPackage ../tools/networking/ncftp { };
applying patches provided by griswold svn path=/nixpkgs/trunk/; revision=19707
2010-01-27 12:12:35 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ncompress = callPackage ../tools/compression/ncompress { };
add bzip2Static svn path=/nixpkgs/trunk/; revision=6269
2006-08-27 14:00:20 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
netcat = callPackage ../tools/networking/netcat { };
Adding netkit tftp client and server. svn path=/nixpkgs/trunk/; revision=16780
2009-08-19 21:19:27 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
netkittftp = callPackage ../tools/networking/netkit/tftp { };
Adding remind and netpbm (maybe without all possible programs). I agree the netpbm installation script is quite ugly, but I left a comment there. svn path=/nixpkgs/trunk/; revision=14253
2009-02-25 22:44:08 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
netpbm = callPackage ../tools/graphics/netpbm { };
netselect = callPackage ../tools/networking/netselect { };
* Added netselect. svn path=/nixpkgs/trunk/; revision=9225
2007-08-31 12:14:05 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
nmap = callPackage ../tools/security/nmap {
Fix typo from previous commit. svn path=/nixpkgs/trunk/; revision=16230
2009-07-07 23:34:03 +01:00
inherit (pythonPackages) pysqlite;
* Clean up indentation (expanded tabs etc.). svn path=/nixpkgs/trunk/; revision=11150
2008-03-17 09:41:28 +00:00
inherit (gtkLibs) gtk;
* Added bsdiff 4.2. Wow, this is even better than zdelta (which in turn appears to be better than vdelta). svn path=/nixpkgs/trunk/; revision=1819
2004-11-29 21:17:29 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ntfs3g = callPackage ../tools/filesystems/ntfs-3g { };
* Refactoring: move most filesystem utilities / FUSE filesystems to tools/filesystems. Previously they were all over the place. svn path=/nixpkgs/trunk/; revision=18809
2009-12-04 15:39:49 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ntfsprogs = callPackage ../tools/filesystems/ntfsprogs { };
* Refactoring: move most filesystem utilities / FUSE filesystems to tools/filesystems. Previously they were all over the place. svn path=/nixpkgs/trunk/; revision=18809
2009-12-04 15:39:49 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ntp = callPackage ../tools/networking/ntp { };
* NTP daemon. svn path=/nixpkgs/trunk/; revision=7459
2006-12-21 22:23:17 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
nssmdns = callPackage ../tools/networking/nss-mdns { };
Add `nss-mdns', an NSS plug-in for the `.local' domain, using mDNS. svn path=/nixpkgs/trunk/; revision=11160
2008-03-17 13:41:54 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
nylon = callPackage ../tools/networking/nylon { };
Adding nylon. svn path=/nixpkgs/trunk/; revision=14254
2009-02-25 23:21:44 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
obex_data_server = callPackage ../tools/bluetooth/obex-data-server {
* Added Blueman (a Bluetooth application). * Added obex-data-server and python-notify, needed by Blueman. svn path=/nixpkgs/trunk/; revision=22497
2010-07-06 15:54:22 +01:00
inherit (gtkLibs) 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 17:26:58 +01:00
obexd = callPackage ../tools/bluetooth/obexd { };
* Added obexd. svn path=/nixpkgs/trunk/; revision=17497
2009-09-29 13:54:08 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
obexfs = callPackage ../tools/bluetooth/obexfs { };
* Various OBEX-related tools. svn path=/nixpkgs/trunk/; revision=16595
2009-08-06 00:24:27 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
obexftp = callPackage ../tools/bluetooth/obexftp { };
* Various OBEX-related tools. svn path=/nixpkgs/trunk/; revision=16595
2009-08-06 00:24:27 +01:00
Adding offlineimap, in a not very elegant way. svn path=/nixpkgs/trunk/; revision=21034
2010-04-12 22:03:22 +01:00
offlineimap = import ../tools/networking/offlineimap {
inherit fetchurl;
# I did not find any better way of reusing buildPythonPackage+setuptools
# for a python with openssl support
buildPythonPackage = assert pythonFull.opensslSupport;
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
import ../development/python-modules/generic {
Adding offlineimap, in a not very elegant way. svn path=/nixpkgs/trunk/; revision=21034
2010-04-12 22:03:22 +01:00
inherit makeWrapper lib;
python = pythonFull;
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
setuptools = builderDefsPackage (import ../development/python-modules/setuptools) {
Adding offlineimap, in a not very elegant way. svn path=/nixpkgs/trunk/; revision=21034
2010-04-12 22:03:22 +01:00
inherit makeWrapper;
python = pythonFull;
};
};
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
opendbx = callPackage ../development/libraries/opendbx { };
added opendbx 1.4.4 svn path=/nixpkgs/trunk/; revision=19872
2010-02-09 09:05:14 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
opendkim = callPackage ../development/libraries/opendkim { };
added libmilter, opendkim svn path=/nixpkgs/trunk/; revision=19875
2010-02-09 10:32:55 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
openjade = callPackage ../tools/text/sgml/openjade {
new: openjade, opensp - by Russell O'Connor svn path=/nixpkgs/trunk/; revision=17926
2009-10-22 16:41:39 +01:00
stdenv = overrideGCC stdenv gcc33;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
openobex = callPackage ../tools/bluetooth/openobex { };
* Various OBEX-related tools. svn path=/nixpkgs/trunk/; revision=16595
2009-08-06 00:24:27 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
opensc_0_11_7 = callPackage ../tools/security/opensc/0.11.7.nix { };
Adding OpenSC, a pkcs11 interface to smartcards. svn path=/nixpkgs/trunk/; revision=19322
2010-01-09 21:52:31 +00:00
Downgrading the opensc library version to 0.11.7, that required for the Spanish national id smartcard (DNIe). Adding the opensc dnie driver. svn path=/nixpkgs/trunk/; revision=19325
2010-01-10 00:22:29 +00: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 17:26:58 +01:00
opensc_dnie_wrapper = callPackage ../tools/security/opensc-dnie-wrapper { };
Adding a global wrapper that provides the user with ready-to-use opensc tools and a 'firefox-dnie' that will launch the firefox in the path with the proper environment variables to allow firefox access the Spanish national id SmartCard as a Security Device. For the later to work cleanly, it will require the user to enable the opensc-pkcs11 module as Security Devices in firefox. svn path=/nixpkgs/trunk/; revision=19452
2010-01-14 23:43:56 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
openssh = callPackage ../tools/networking/openssh {
pkgs/top-level/all-packages.nix, pkgs/tools/networking/openssh: prefer makeOverridable over getPkgConfig to customize openssh Changed 'openssh' expression to allow for argument overriding instead of relying on getPkgConfig. While I was at it, I also simplified the build expression a bit. svn path=/nixpkgs/trunk/; revision=21868
2010-05-19 13:26:06 +01:00
hpnSupport = false;
etcDir = "/etc/ssh";
* Updates paths in all-packages-generic.fix. svn path=/nixpkgs/trunk/; revision=472
2003-11-03 18:21:30 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
opensp = callPackage ../tools/text/sgml/opensp { };
new: openjade, opensp - by Russell O'Connor svn path=/nixpkgs/trunk/; revision=17926
2009-10-22 16:41:39 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
openvpn = callPackage ../tools/networking/openvpn { };
adding openvpn svn path=/nixpkgs/trunk/; revision=14901
2009-04-06 14:07:18 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
optipng = callPackage ../tools/graphics/optipng { };
Adding optipng, and a basic expression for pdfread. svn path=/nixpkgs/trunk/; revision=20802
2010-03-23 23:04:41 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
p7zip = callPackage ../tools/archivers/p7zip { };
* Added p7zip for decompressing 7-zip archives. svn path=/nixpkgs/trunk/; revision=9248
2007-09-04 12:55:19 +01:00
Adding the calendar program 'pal' svn path=/nixpkgs/trunk/; revision=23070
2010-08-09 22:13:36 +01:00
pal = callPackage ../tools/misc/pal {
inherit (gtkLibs) 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 17:26:58 +01:00
panomatic = callPackage ../tools/graphics/panomatic { };
Adding panomatic. svn path=/nixpkgs/trunk/; revision=14981
2009-04-10 10:42:22 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
par2cmdline = callPackage ../tools/networking/par2cmdline { };
added packages: which, libtool aggregation in all-packages-generic: autotools building strategoxt from svn not complete yet since autconf cannot find libtool svn path=/nixpkgs/trunk/; revision=596
2003-12-23 20:51:58 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
parallel = callPackage ../tools/misc/parallel { };
Add GNU Parallel. svn path=/nixpkgs/trunk/; revision=21552
2010-05-02 10:27:32 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
patchutils = callPackage ../tools/text/patchutils { };
added patchutils svn path=/nixpkgs/trunk/; revision=12387
2008-07-19 00:36:28 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
parted = callPackage ../tools/misc/parted { };
* Added GNU wget to the stdenv. svn path=/nixpkgs/trunk/; revision=477
2003-11-04 08:44:46 +00:00
* Delete some obsolete packages. * Make sure that every package in all-packages.nix has a unique name. Not all of them do, but there are now a few helper functions that modify the name of a package for display purposes in nix-env (e.g., you get "zlib-1.2.3" and "zlib-1.2.3-static" in "nix-env -qa"). svn path=/nixpkgs/trunk/; revision=8607
2007-04-26 14:02:30 +01: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 16:53:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pbzip2 = callPackage ../tools/compression/pbzip2 { };
Adding pbzip2 (Parallel bzip2 for multicore machines) svn path=/nixpkgs/trunk/; revision=19011
2009-12-17 11:10:01 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pciutils = callPackage ../tools/system/pciutils { };
* Latest pciutils. svn path=/nixpkgs/trunk/; revision=7914
2007-02-19 20:18:20 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pcsclite = callPackage ../tools/security/pcsclite { };
Adding pcsclite with the opensource ccid usb drivers. This gives a daemon controlling the smartcard reader used to read the Spanish identity card. svn path=/nixpkgs/trunk/; revision=19319
2010-01-09 17:35:57 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pdf2djvu = callPackage ../tools/typesetting/pdf2djvu { };
Adding pdf2djvu, updating djvulibre, and getting more headers from poppler. svn path=/nixpkgs/trunk/; revision=14760
2009-03-29 21:32:41 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pdfjam = callPackage ../tools/typesetting/pdfjam { };
A pkgs/tools/typesetting/pdfjam A pkgs/tools/typesetting/pdfjam/builder.sh A pkgs/tools/typesetting/pdfjam/default.nix Added pdfjam, a package with the following tools: * pdfnup, which allows PDF files to be "n-upped" in roughly the way that psnup does for PostScript files. * pdfjoin, which concatenates the pages of multiple PDF files together into a single file * pdf90, which rotates the pages of one or more PDF files through 90 degrees (anti-clockwise). M pkgs/development/compilers/jdk/jdk6-linux.nix Typo svn path=/nixpkgs/trunk/; revision=8404
2007-03-21 12:53:01 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pdfread = callPackage ../tools/graphics/pdfread { };
Adding optipng, and a basic expression for pdfread. svn path=/nixpkgs/trunk/; revision=20802
2010-03-23 23:04:41 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pg_top = callPackage ../tools/misc/pg_top { };
added pg_top svn path=/nixpkgs/trunk/; revision=17711
2009-10-08 09:53:21 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
pdsh = callPackage ../tools/networking/pdsh {
Add latest Linux kernel for real i686 platform, not modern amd64-in-32bit-mode svn path=/nixpkgs/trunk/; revision=23173
2010-08-14 17:04:02 +01:00
rsh = true; # enable internal rsh implementation
pkgs/top-level/all-packages.nix: prefer makeOverridable over getPkgConfig to customize pdsh Changed 'pdsh' expression to allow for argument overriding instead of relying on getPkgConfig. svn path=/nixpkgs/trunk/; revision=21867
2010-05-19 13:26:00 +01:00
ssh = openssh;
new: pdsh is a fast and efficient parallel remote shell svn path=/nixpkgs/trunk/; revision=12313
2008-07-08 00:11:36 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
pfstools = callPackage ../tools/graphics/pfstools {
Adding qtpfsgui and pfstools. Updating fftw because the src URL didn't work anymore. svn path=/nixpkgs/trunk/; revision=14892
2009-04-05 22:41:13 +01:00
qt = qt3;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
pinentry = callPackage ../tools/misc/pinentry {
added missing top-level attribute pinentry svn path=/nixpkgs/trunk/; revision=11725
2008-04-26 00:43:14 +01: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 17:26:58 +01:00
pius = callPackage ../tools/security/pius { };
Add PIUS. svn path=/nixpkgs/trunk/; revision=22580
2010-07-13 17:32:14 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pk2cmd = callPackage ../tools/misc/pk2cmd { };
Adding the Microchip software for the PICKit2 programmer: pk2cmd svn path=/nixpkgs/trunk/; revision=21726
2010-05-11 17:17:26 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
plan9port = callPackage ../tools/system/plan9port { };
Adding plan9port with X11 support. For acme to work, set the PLAN9 variable, and have the plan9port programs in the PATH. svn path=/nixpkgs/trunk/; revision=14669
2009-03-23 21:31:30 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ploticus = callPackage ../tools/graphics/ploticus { };
add eject, but remove the po subdir svn path=/nixpkgs/trunk/; revision=3766
2005-09-01 17:38:31 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
plotutils = callPackage ../tools/graphics/plotutils { };
adding plotutils svn path=/nixpkgs/trunk/; revision=17862
2009-10-18 05:43:50 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pngnq = callPackage ../tools/graphics/pngnq { };
Adding pngnq. svn path=/nixpkgs/trunk/; revision=20801
2010-03-23 22:40:46 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
povray = callPackage ../tools/graphics/povray { };
Adding povray svn path=/nixpkgs/trunk/; revision=15598
2009-05-14 09:49:46 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ppl = callPackage ../development/libraries/ppl { };
Add the Parma Polyhedra Library (PPL), an optional dependency of GCC 4.4. svn path=/nixpkgs/trunk/; revision=16421
2009-07-18 22:22:13 +01:00
Adding ppp and rp-pppoe for different point-to-point connectivity situations. Not tested for trivial reasons, but built OK svn path=/nixpkgs/trunk/; revision=13925
2009-02-01 13:54:20 +00:00
/* WARNING: this version is unsuitable for using with a setuid wrapper */
ppp = builderDefsPackage (import ../tools/networking/ppp) {
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
proxychains = callPackage ../tools/networking/proxychains { };
Committing Lluís Batlle's submissions from mailing list posting <45219fb00901110456i6f21db35tbd1894eaea2146ff@mail.gmail.com>: * nixpkgs-ccrypt-1.7-new.patch * nixpkgs-cmake-add-ccmake.patch * nixpkgs-cpufrequtils-005-new.patch * nixpkgs-dwm-5.1-fix.patch * nixpkgs-freeimage-3.11.0-new.patch * nixpkgs-proxychains-3.1-new.patch * nixpkgs-psi-to-0.12.patch * nixpkgs-skype-to-2.0.0.72.patch * nixpkgs-truecrypt-6.1a-fix.patch * nixpkgs-vxl-1.11.0-new.patch * nixpkgs-xkb-popular-esperanto-symbols.patch * nixpkgs-xorg-via-video-fix.patch svn path=/nixpkgs/trunk/; revision=13751
2009-01-12 21:12:07 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
proxytunnel = callPackage ../tools/misc/proxytunnel { };
Added proxy tunnel tool svn path=/nixpkgs/trunk/; revision=12814
2008-09-06 13:33:25 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
psmisc = callPackage ../tools/misc/psmisc { };
* Added psmisc. svn path=/nixpkgs/trunk/; revision=9905
2007-12-11 11:47:23 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pstoedit = callPackage ../tools/graphics/pstoedit { };
adding ps2edit svn path=/nixpkgs/trunk/; revision=17863
2009-10-18 05:43:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pv = callPackage ../tools/misc/pv { };
Adding pipe viewer. svn path=/nixpkgs/trunk/; revision=14643
2009-03-22 12:34:30 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pwgen = callPackage ../tools/security/pwgen { };
* ncurses: added symlinks for bynary packages linked against libncurses. Tested with ghc. I will add 'unicode' option next check in (for cygwin). * pidgin: Got rid of builder.sh, added ncurses to the dependencies, so it builds finch. * xorg: Added glproto and mesaHeaders to xf86videosis dependencies. Now it compiles. * pwgen: Added. * device-mapper: Version bump. Added 'static' option for use in initrd. * lvm2: Version bump. Added 'static' option for use in initrd. svn path=/nixpkgs/trunk/; revision=8923
2007-06-28 10:53:12 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pydb = callPackage ../tools/pydb { };
adding pydb, a python debugging with gdb like commands svn path=/nixpkgs/trunk/; revision=15317
2009-04-26 12:06:51 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pystringtemplate = callPackage ../development/python-modules/stringtemplate { };
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
pythonDBus = builderDefsPackage (import ../development/python-modules/dbus) {
inherit python pkgconfig dbus_glib;
dbus = dbus.libs;
};
pythonIRClib = builderDefsPackage (import ../development/python-modules/irclib) {
inherit python;
};
pythonSexy = builderDefsPackage (import ../development/python-modules/libsexy) {
inherit python libsexy pkgconfig libxml2 pygtk;
inherit (gtkLibs) pango gtk 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 17:26:58 +01:00
openmpi = callPackage ../development/libraries/openmpi { };
* added mcrl, mcrl2 and openmpi to all-packages.nix svn path=/nixpkgs/trunk/; revision=15874
2009-06-05 15:36:35 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
qdu = callPackage ../tools/misc/qdu { };
add qdu: a graphical disk usage based on qt. svn path=/nixpkgs/trunk/; revision=22021
2010-05-27 20:44:12 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
qhull = callPackage ../development/libraries/qhull { };
Adding qhull, and updating octaves. svn path=/nixpkgs/trunk/; revision=14955
2009-04-08 21:06:03 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
qshowdiff = callPackage ../tools/text/qshowdiff {
Adding qshowdiff. svn path=/nixpkgs/trunk/; revision=20633
2010-03-15 14:26:52 +00:00
qt = qt4;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
rtmpdump = callPackage ../tools/video/rtmpdump { };
Adding rtmpdump svn path=/nixpkgs/trunk/; revision=21468
2010-04-30 22:46:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
reiser4progs = callPackage ../tools/filesystems/reiser4progs { };
* Refactoring: move most filesystem utilities / FUSE filesystems to tools/filesystems. Previously they were all over the place. svn path=/nixpkgs/trunk/; revision=18809
2009-12-04 15:39:49 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
reiserfsprogs = callPackage ../tools/filesystems/reiserfsprogs { };
* Refactoring: move most filesystem utilities / FUSE filesystems to tools/filesystems. Previously they were all over the place. svn path=/nixpkgs/trunk/; revision=18809
2009-12-04 15:39:49 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
relfs = callPackage ../tools/filesystems/relfs {
Added Relational FS svn path=/nixpkgs/trunk/; revision=9865
2007-12-06 00:32:21 +00:00
inherit (gnome) gnomevfs GConf;
svn path=/nixpkgs/trunk/; revision=9861
2007-12-04 22:06:13 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
remind = callPackage ../tools/misc/remind { };
Adding remind and netpbm (maybe without all possible programs). I agree the netpbm installation script is quite ugly, but I left a comment there. svn path=/nixpkgs/trunk/; revision=14253
2009-02-25 22:44:08 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
replace = callPackage ../tools/text/replace { };
Added replace. Maybe abandon sed for substituteAll ? svn path=/nixpkgs/trunk/; revision=8987
2007-07-15 12:59:33 +01:00
* librsync is missing. * mkDerivationByConfigruation wasn't commented out correctly (no nested comments, unfortunately). svn path=/nixpkgs/trunk/; revision=9287
2007-09-10 15:29:45 +01:00
/*
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
rdiff_backup = callPackage ../tools/backup/rdiff-backup {
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
python=python; };
* librsync is missing. * mkDerivationByConfigruation wasn't commented out correctly (no nested comments, unfortunately). svn path=/nixpkgs/trunk/; revision=9287
2007-09-10 15:29:45 +01:00
*/
rdiff-backup added svn path=/nixpkgs/trunk/; revision=9280
2007-09-08 21:45:23 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
rsnapshot = callPackage ../tools/backup/rsnapshot {
Add rsnapshot, an rsync-based remote backup tool. svn path=/nixpkgs/trunk/; revision=11009
2008-03-07 09:33:51 +00: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 17:26:58 +01:00
rlwrap = callPackage ../tools/misc/rlwrap { };
Added rlwrap - readline wrapper svn path=/nixpkgs/trunk/; revision=10271
2008-01-23 23:39:06 +00:00
Adding ppp and rp-pppoe for different point-to-point connectivity situations. Not tested for trivial reasons, but built OK svn path=/nixpkgs/trunk/; revision=13925
2009-02-01 13:54:20 +00:00
rpPPPoE = builderDefsPackage (import ../tools/networking/rp-pppoe) {
inherit ppp;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
rpm = callPackage ../tools/package-management/rpm {
* RPM updated to 4.7.2. * nspr updated to 4.8.2. * nss updated to 3.12.4. * elfutils updated to 0.143. svn path=/nixpkgs/trunk/; revision=18867
2009-12-09 22:34:51 +00:00
db4 = db45;
* Revived RPM. Damn, RPM is nasty to build. svn path=/nixpkgs/trunk/; revision=8407
2007-03-21 19:25:58 +00:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
rrdtool = callPackage ../tools/misc/rrdtool {
Adding rrdtool. svn path=/nixpkgs/trunk/; revision=14713
2009-03-25 19:13:24 +00: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 17:26:58 +01:00
rtorrent = callPackage ../tools/networking/p2p/rtorrent { };
Added libtorrent a bittorent library written in C++ for *nix and rtorrent a ncurses client for libtorrent. svn path=/nixpkgs/trunk/; revision=10842
2008-02-23 12:11:27 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
rubber = callPackage ../tools/typesetting/rubber { };
Add Rubber, a LaTeX wrapper that does the right thing. svn path=/nixpkgs/trunk/; revision=14551
2009-03-16 10:42:51 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
rxp = callPackage ../tools/text/xml/rxp { };
Add all my latest packages to all-packages.nix svn path=/nixpkgs/trunk/; revision=12957
2008-10-05 10:04:30 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
rzip = callPackage ../tools/compression/rzip { };
Adding lrzip and rzip. svn path=/nixpkgs/trunk/; revision=14581
2009-03-17 21:17:51 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
s3backer = callPackage ../tools/filesystems/s3backer { };
* Added s3backer. svn path=/nixpkgs/trunk/; revision=18811
2009-12-04 15:51:02 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
s3sync = callPackage ../tools/networking/s3sync { };
* Added s3sync. svn path=/nixpkgs/trunk/; revision=20496
2010-03-09 15:12:15 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
sablotron = callPackage ../tools/text/xml/sablotron { };
* Added BitTorrent. svn path=/nixpkgs/trunk/; revision=797
2004-02-17 20:03:12 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
screen = callPackage ../tools/misc/screen { };
* JDK: put the machine-dependent header files in the right place. * Added SWT for GTK (built from source). * Added Azureus (a Bittorrent client written in Java). svn path=/nixpkgs/trunk/; revision=4438
2005-12-26 00:51:24 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
scrot = callPackage ../tools/graphics/scrot { };
* Added scrot, a command-line screen capture utility. svn path=/nixpkgs/trunk/; revision=16946
2009-09-02 23:56:33 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
seccure = callPackage ../tools/security/seccure/0.4.nix { };
Added Shamir Secret Sharing Scheme and bmrsa. Fixed libgcrypt svn path=/nixpkgs/trunk/; revision=10928
2008-03-03 12:30:39 +00:00
Adding setserial svn path=/nixpkgs/trunk/; revision=15898
2009-06-09 05:22:46 +01:00
setserial = builderDefsPackage (import ../tools/system/setserial) {
inherit groff;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
sharutils = callPackage ../tools/archivers/sharutils { };
sharutils added (4.6.3) svn path=/nixpkgs/branches/stdenv-updates/; revision=10744
2008-02-18 20:52:25 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
shebangfix = callPackage ../tools/misc/shebangfix { };
added small script fixing the shebang (#!/bin/...) path. It searches the PATH env variable for the same executable. svn path=/nixpkgs/trunk/; revision=9667
2007-11-14 19:07:38 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
slimrat = callPackage ../tools/networking/slimrat {
Adding slimrat (not the gui, but at least the cli) svn path=/nixpkgs/trunk/; revision=20999
2010-04-10 11:47:30 +01: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 17:26:58 +01:00
slsnif = callPackage ../tools/misc/slsnif { };
slsnif-0.4.4 added svn path=/nixpkgs/trunk/; revision=12679
2008-08-21 12:07:29 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
smartmontools = callPackage ../tools/system/smartmontools { };
* Added smartmontools. svn path=/nixpkgs/trunk/; revision=9466
2007-10-18 14:05:43 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
fusesmb = callPackage ../tools/filesystems/fusesmb { };
Added smbfsFuse (executable name fusesmb) svn path=/nixpkgs/trunk/; revision=10285
2008-01-25 10:15:19 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
socat = callPackage ../tools/networking/socat { };
Added socat, updated zsh svn path=/nixpkgs/trunk/; revision=10470
2008-02-03 11:03:54 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
sourceHighlight = callPackage ../tools/text/source-highlight { };
pkgs/tools/text/source-highlight: added GNU source highlight version 3.1.3 svn path=/nixpkgs/trunk/; revision=21457
2010-04-30 13:23:26 +01:00
Fix the cleanup-induced problems svn path=/nixpkgs/trunk/; revision=18554
2009-11-23 12:21:34 +00: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 17:26:58 +01:00
squashfsTools = callPackage ../tools/filesystems/squashfs { };
* Refactoring: move most filesystem utilities / FUSE filesystems to tools/filesystems. Previously they were all over the place. svn path=/nixpkgs/trunk/; revision=18809
2009-12-04 15:39:49 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
sshfsFuse = callPackage ../tools/filesystems/sshfs-fuse { };
* Refactoring: move most filesystem utilities / FUSE filesystems to tools/filesystems. Previously they were all over the place. svn path=/nixpkgs/trunk/; revision=18809
2009-12-04 15:39:49 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
sudo = callPackage ../tools/security/sudo { };
Added sudo. svn path=/nixpkgs/trunk/; revision=8898
2007-06-20 00:55:02 +01:00
Added setuid-ready chroot utility. svn path=/nixpkgs/trunk/; revision=16331
2009-07-12 09:10:51 +01:00
suidChroot = builderDefsPackage (import ../tools/system/suid-chroot) {
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
ssmtp = callPackage ../tools/networking/ssmtp {
* Build ssmtp with TLS support. * Added gnutls (but it turns out that ssmtp also builds with openssl, so I don't actually use it). svn path=/nixpkgs/trunk/; revision=9604
2007-11-08 17:48:52 +00:00
tlsSupport = true;
* add ssmtp still rather rough around the edges: - example config files are installed to $out/etc/ssmtp - the binary expects config files in /etc/ssmtp - it's the user's responsibility to add the global config files svn path=/nixpkgs/trunk/; revision=9064
2007-08-07 23:22:31 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ssss = callPackage ../tools/security/ssss { };
Added Shamir Secret Sharing Scheme and bmrsa. Fixed libgcrypt svn path=/nixpkgs/trunk/; revision=10928
2008-03-03 12:30:39 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
stun = callPackage ../tools/networking/stun { };
adding stun svn path=/nixpkgs/trunk/; revision=17860
2009-10-18 05:43:45 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
stunnel = callPackage ../tools/networking/stunnel { };
add stunnel svn path=/nixpkgs/trunk/; revision=14301
2009-03-02 15:23:52 +00:00
* Remove our hacked up version of `su' from coreutils. svn path=/nixpkgs/trunk/; revision=22108
2010-06-02 22:11:21 +01:00
su = shadow;
* Add a working PAM-enabled su. svn path=/nixpkgs/trunk/; revision=7633
2007-01-11 15:22:59 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
swec = callPackage ../tools/networking/swec {
Add SWEC (Simple Web Error Checker). svn path=/nixpkgs/trunk/; revision=19637
2010-01-24 19:07:16 +00: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 17:26:58 +01:00
svnfs = callPackage ../tools/filesystems/svnfs { };
adding svnFS svn path=/nixpkgs/trunk/; revision=21132
2010-04-16 16:56:31 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
system_config_printer = callPackage ../tools/misc/system-config-printer { };
Use $NIXPKGS_CONFIG to determine whether ghostscript has cups support. svn path=/nixpkgs/trunk/; revision=14275
2009-02-27 13:44:31 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
sitecopy = callPackage ../tools/networking/sitecopy {
Add neon-0.29.x, make it default Also stop using "default" neon in all-packages.nix. Minor versions are not source-compatible, so a package should state needed version explicitly. svn path=/nixpkgs/trunk/; revision=21394
2010-04-28 09:40:19 +01:00
neon = neon026;
added sitecopy svn path=/nixpkgs/trunk/; revision=17638
2009-10-05 11:37:30 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
privoxy = callPackage ../tools/networking/privoxy {
Making privoxy build (set an older autoconf - the current privxoy does not like the newer) svn path=/nixpkgs/trunk/; revision=22503
2010-07-07 09:58:56 +01:00
autoconf = autoconf213;
added privoxy svn path=/nixpkgs/trunk/; revision=17645
2009-10-05 15:15:28 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
tcpdump = callPackage ../tools/networking/tcpdump { };
* Added tcpdump. svn path=/nixpkgs/trunk/; revision=7697
2007-01-16 14:35:08 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
tcng = callPackage ../tools/networking/tcng {
Rename `kernel*' to `linux*'. svn path=/nixpkgs/branches/stdenv-updates/; revision=19068
2009-12-21 14:12:00 +00:00
kernel = linux_2_6_28;
adding tcng package tcc can be used to generate tc traffic shaping commands. It even can compile kernel modules to classify packages (untested) svn path=/nixpkgs/trunk/; revision=14574
2009-03-17 14:18:45 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
telnet = callPackage ../tools/networking/telnet { };
* Added a telnet client. svn path=/nixpkgs/trunk/; revision=9431
2007-10-09 10:56:39 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
texmacs = callPackage ../applications/office/texmacs { };
Add GNU TeXmacs. svn path=/nixpkgs/trunk/; revision=19985
2010-02-13 19:22:16 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
tor = callPackage ../tools/security/tor { };
Adding tor 0.2.1.26 (Patch sent by roconnor) svn path=/nixpkgs/trunk/; revision=21797
2010-05-16 17:23:32 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ttf2pt1 = callPackage ../tools/misc/ttf2pt1 { };
* Removed applications/msic, a rather obvious typo. svn path=/nixpkgs/trunk/; revision=15149
2009-04-19 12:47:01 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ucl = callPackage ../development/libraries/ucl { };
Adding upx. svn path=/nixpkgs/trunk/; revision=14645
2009-03-22 13:03:37 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
ufraw = callPackage ../applications/graphics/ufraw {
Add UFRaw. svn path=/nixpkgs/trunk/; revision=17881
2009-10-19 13:50:45 +01:00
inherit (gnome) gtk;
};
* Added UNetbootin, a program for creating bootable USB sticks from ISO images. svn path=/nixpkgs/trunk/; revision=23018
2010-08-06 23:33:14 +01:00
unetbootin = callPackage ../tools/cd-dvd/unetbootin { };
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
upx = callPackage ../tools/compression/upx { };
Adding upx. svn path=/nixpkgs/trunk/; revision=14645
2009-03-22 13:03:37 +00:00
Adding vbetool svn path=/nixpkgs/trunk/; revision=17952
2009-10-24 20:58:07 +01:00
vbetool = builderDefsPackage ../tools/system/vbetool {
inherit pciutils libx86 zlib;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
viking = callPackage ../applications/misc/viking {
Add Viking, a GPS trace editor. svn path=/nixpkgs/trunk/; revision=15804
2009-05-30 21:52:10 +01:00
inherit (gtkLibs) gtk;
};
Adding vncrec - a VNC recorder svn path=/nixpkgs/trunk/; revision=16603
2009-08-07 13:00:00 +01:00
vncrec = builderDefsPackage ../tools/video/vncrec {
inherit (xlibs) imake libX11 xproto gccmakedep libXt
libXmu libXaw libXext xextproto libSM libICE libXpm
libXp;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
vpnc = callPackage ../tools/networking/vpnc { };
Add VPNC, a Cisco-compatible VPN client. svn path=/nixpkgs/trunk/; revision=10618
2008-02-10 21:54:01 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
vtun = callPackage ../tools/networking/vtun { };
Adding vtun. svn path=/nixpkgs/trunk/; revision=15682
2009-05-20 18:51:41 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
testdisk = callPackage ../tools/misc/testdisk { };
* Added TestDisk, a program for fixing unbootable disks. svn path=/nixpkgs/trunk/; revision=9318
2007-09-12 16:49:28 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
htmlTidy = callPackage ../tools/text/html-tidy { };
Add HTML Tidy, an HTML validator. svn path=/nixpkgs/trunk/; revision=16176
2009-07-05 15:07:39 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
tigervnc = callPackage ../tools/admin/tigervnc {
Making the tigervnc server work. svn path=/nixpkgs/trunk/; revision=22584
2010-07-13 18:57:13 +01:00
fontDirectories = [ xorg.fontadobe75dpi xorg.fontmiscmisc xorg.fontcursormisc
xorg.fontbhlucidatypewriter75dpi ];
TigerVNC (without the server Xvnc still) svn path=/nixpkgs/trunk/; revision=22568
2010-07-12 23:15:36 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
tightvnc = callPackage ../tools/admin/tightvnc {
Making tightvnc use given fonts, instead of depending of an X Font Server started at the usual unix socket. svn path=/nixpkgs/trunk/; revision=15624
2009-05-17 00:04:06 +01:00
fontDirectories = [ xorg.fontadobe75dpi xorg.fontmiscmisc xorg.fontcursormisc
xorg.fontbhlucidatypewriter75dpi ];
* Added gtk-gnutella. * Added a patch to MPlayer to fix the aspect ratio on screens rotated with Xrandr. * Disable toolbus for now because it requires a non-existant package (tcltk). svn path=/nixpkgs/trunk/; revision=5171
2006-04-18 19:46:36 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
time = callPackage ../tools/misc/time { };
* Added the GNU `time' command. svn path=/nixpkgs/trunk/; revision=8599
2007-04-20 09:50:26 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
tm = callPackage ../tools/system/tm { };
tm (terminal mixer), ts (task spooler) added, provided by viric svn path=/nixpkgs/trunk/; revision=12688
2008-08-21 22:35:14 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
trang = callPackage ../tools/text/xml/trang { };
add groff, needed for dhcp svn path=/nixpkgs/trunk/; revision=3651
2005-08-21 14:59:04 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
tre = callPackage ../development/libraries/tre { };
added tre-0.8.0 svn path=/nixpkgs/trunk/; revision=19873
2010-02-09 09:09:25 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ts = callPackage ../tools/system/ts { };
tm (terminal mixer), ts (task spooler) added, provided by viric svn path=/nixpkgs/trunk/; revision=12688
2008-08-21 22:35:14 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
transfig = callPackage ../tools/graphics/transfig { };
add a wrapper for dhclient svn path=/nixpkgs/trunk/; revision=3655
2005-08-21 20:46:16 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
truecrypt = callPackage ../applications/misc/truecrypt {
Fixing truecrypt They removed the url for that package version, I updated to the latest. I changed the name from 'trueCrypt' to 'truecrypt' I added an option for it not to have a gui built. svn path=/nixpkgs/trunk/; revision=17587
2009-10-02 09:00:30 +01:00
wxGUI = getConfig [ "truecrypt" "wxGUI" ] true;
truecrypt svn path=/nixpkgs/trunk/; revision=12389
2008-07-19 17:14:24 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
ttmkfdir = callPackage ../tools/misc/ttmkfdir {
Added template to use deb-package wrapper. svn path=/nixpkgs/trunk/; revision=10911
2008-03-02 18:41:32 +00:00
flex = flex2534;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
unbound = callPackage ../tools/networking/unbound { };
unbound 1.4.1 svn path=/nixpkgs/trunk/; revision=19870
2010-02-09 07:28:32 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
units = callPackage ../tools/misc/units { };
Added GNU units - unit conversion tool. svn path=/nixpkgs/trunk/; revision=8907
2007-06-20 16:15:51 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
unrar = callPackage ../tools/archivers/unrar { };
Added unrar svn path=/nixpkgs/trunk/; revision=8916
2007-06-24 16:34:44 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
unshield = callPackage ../tools/archivers/unshield { };
* Added unshield, a program for unpacking InstallShield CAB files (which are different from Windows Installer CAB files). svn path=/nixpkgs/trunk/; revision=8797
2007-05-28 18:09:30 +01:00
* Unzip 6.0. svn path=/nixpkgs/trunk/; revision=17687
2009-10-07 12:18:54 +01:00
unzip = unzip552;
# TODO: remove in the next stdenv update.
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
unzip552 = callPackage ../tools/archivers/unzip/5.52.nix { };
* Added libexif and the exif frontend utility. svn path=/nixpkgs/trunk/; revision=2376
2005-03-11 10:46:20 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
unzip60 = callPackage ../tools/archivers/unzip/6.0.nix { };
* Unzip 6.0. svn path=/nixpkgs/trunk/; revision=17687
2009-10-07 12:18:54 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
uptimed = callPackage ../tools/system/uptimed { };
* added uptimed 0.3.16 svn path=/nixpkgs/trunk/; revision=17172
2009-09-16 08:31:16 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
w3cCSSValidator = callPackage ../tools/misc/w3c-css-validator {
adding w3c CSS validator svn path=/nixpkgs/trunk/; revision=19635
2010-01-24 15:39:42 +00:00
tomcat = tomcat6;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
wdfs = callPackage ../tools/filesystems/wdfs {
Add neon-0.29.x, make it default Also stop using "default" neon in all-packages.nix. Minor versions are not source-compatible, so a package should state needed version explicitly. svn path=/nixpkgs/trunk/; revision=21394
2010-04-28 09:40:19 +01:00
neon = neon026;
new: wdfs-1.4.2 is a user-space file system that allows mounting a webdav share svn path=/nixpkgs/trunk/; revision=12316
2008-07-08 00:24:48 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
wdiff = callPackage ../tools/text/wdiff { };
* Added GNU wdiff. svn path=/nixpkgs/trunk/; revision=20817
2010-03-25 11:51:55 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
webalizer = callPackage ../tools/networking/webalizer { };
nix 0.15pre20231 as nixUnstable svn path=/nixpkgs/trunk/; revision=20243
2010-02-25 10:01:33 +00:00
Adding WebDruid log analyzer. In the same time, reworking source autoupdate system a bit svn path=/nixpkgs/trunk/; revision=16859
2009-08-26 12:13:36 +01:00
webdruid = builderDefsPackage ../tools/admin/webdruid {
xlock: fixed build and updated to version 5.24 svn path=/nixpkgs/trunk/; revision=17356
2009-09-22 21:16:38 +01:00
inherit zlib libpng freetype gd which
Adding WebDruid log analyzer. In the same time, reworking source autoupdate system a bit svn path=/nixpkgs/trunk/; revision=16859
2009-08-26 12:13:36 +01:00
libxml2 geoip;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
wget = callPackage ../tools/networking/wget {
GNU wget: Fix test suite runs. svn path=/nixpkgs/trunk/; revision=21057
2010-04-13 11:11:42 +01:00
inherit (perlPackages) LWP;
Added transfig, opefully the ugliest package of this world svn path=/nixpkgs/trunk/; revision=5751
2006-07-17 21:35:02 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
which = callPackage ../tools/system/which { };
* modified tetex to support extra .sty's from other packages * added lazylist and polytable (both tetex packages) * added lhs2tex ebuild, depending on the two above svn path=/nixpkgs/trunk/; revision=4609
2006-01-27 20:51:41 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
wicd = callPackage ../tools/networking/wicd { };
Adding wicd, written by roconnor, sent to the nix-dev list on 2010-01-07 svn path=/nixpkgs/trunk/; revision=19297
2010-01-07 17:49:45 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
wv = callPackage ../tools/misc/wv { };
Added wvVare - tools for converting Microsoft Word formats to usable ones. svn path=/nixpkgs/trunk/; revision=9152
2007-08-18 09:32:12 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
wv2 = callPackage ../tools/misc/wv2 { };
Added wv2 library svn path=/nixpkgs/trunk/; revision=15777
2009-05-28 20:22:32 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
x11_ssh_askpass = callPackage ../tools/networking/x11-ssh-askpass { };
* Added x11-ssh-askpass. svn path=/nixpkgs/trunk/; revision=8529
2007-04-02 14:46:56 +01:00
Adding xburst-tools to manage the USB_BOOT mode of the Ben Nanonote (reflashing, ...) I add the 'confuse' library as a side effect. svn path=/nixpkgs/trunk/; revision=22817
2010-07-30 00:25:42 +01:00
xbursttools = import ../tools/misc/xburst-tools {
inherit stdenv fetchgit autoconf automake libusb confuse;
Making the xburst-tools for the Ben Nanonote build the firmware they need to communicate with it. This involves making a cross-compiler for mipsel. svn path=/nixpkgs/trunk/; revision=22818
2010-07-30 00:26:07 +01:00
# It needs a cross compiler for mipsel to build the firmware it will
# load into the Ben Nanonote
gccCross = let
pkgsCross = (import ./all-packages.nix) {
inherit system;
inherit bootStdenv noSysDirs gccWithCC gccWithProfiling config;
# Ben Nanonote system
crossSystem = {
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
config = "mipsel-unknown-linux";
Making the xburst-tools for the Ben Nanonote build the firmware they need to communicate with it. This involves making a cross-compiler for mipsel. svn path=/nixpkgs/trunk/; revision=22818
2010-07-30 00:26:07 +01: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";
};
};
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
in
Making the xburst-tools for the Ben Nanonote build the firmware they need to communicate with it. This involves making a cross-compiler for mipsel. svn path=/nixpkgs/trunk/; revision=22818
2010-07-30 00:26:07 +01:00
pkgsCross.gccCrossStageStatic;
Adding xburst-tools to manage the USB_BOOT mode of the Ben Nanonote (reflashing, ...) I add the 'confuse' library as a side effect. svn path=/nixpkgs/trunk/; revision=22817
2010-07-30 00:25:42 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xclip = callPackage ../tools/misc/xclip { };
xclip added svn path=/nixpkgs/trunk/; revision=9355
2007-09-21 22:40:23 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xfsprogs = callPackage ../tools/filesystems/xfsprogs { };
* Refactoring: move most filesystem utilities / FUSE filesystems to tools/filesystems. Previously they were all over the place. svn path=/nixpkgs/trunk/; revision=18809
2009-12-04 15:39:49 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
xmlroff = callPackage ../tools/typesetting/xmlroff {
Added pangoxsl and xmlroff svn path=/nixpkgs/trunk/; revision=3574
2005-08-13 22:35:49 +01:00
inherit (gtkLibs) glib pango gtk;
inherit (gnome) libgnomeprint;
Added jing-tools to the cache svn path=/nixpkgs/trunk/; revision=3570
2005-08-13 19:12:10 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xmlto = callPackage ../tools/typesetting/xmlto { };
Add `xmlto', a front-end to an XSL toolchain. svn path=/nixpkgs/trunk/; revision=11048
2008-03-11 08:44:22 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xmltv = callPackage ../tools/misc/xmltv { };
* Qt: add optional support for MySQL. * MythTV: the setup program works :-). * Added XmlTV. This requires a huge number of Perl modules, so... * Added a generic builder for Perl modules. I'm lazy so the modules are defined directly in all-packages-generic.nix. The generic builder also patches Perl scripts to include a hard-coded Perl module search path (i.e., similar to an RPATH in ELF executables). svn path=/nixpkgs/trunk/; revision=2083
2005-01-22 00:19:27 +00:00
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
xmpppy = builderDefsPackage (import ../development/python-modules/xmpppy) {
inherit python setuptools;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
xpf = callPackage ../tools/text/xml/xpf {
* Disable some Haskell packages on Darwin. svn path=/nixpkgs/branches/stdenv-updates/; revision=15270
2009-04-23 13:33:09 +01:00
libxml2 = libxml2Python;
- add mktemp - disable tiger, strategoxt, they don't work and give errors - ftp.nl.kernel.org seems to have some problems, replaced with ftp.de.kernel.org should be put back eventually svn path=/nixpkgs/trunk/; revision=1215
2004-08-03 16:41:08 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xsel = callPackage ../tools/misc/xsel { };
also add nmap here svn path=/nixpkgs/trunk/; revision=1238
2004-08-06 11:01:15 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
zdelta = callPackage ../tools/compression/zdelta { };
* GnuPG updated to 1.4.2. Added support to optionally build it with IDEA support (requires a license). svn path=/nixpkgs/trunk/; revision=4399
2005-12-18 22:14:31 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
zile = callPackage ../applications/editors/zile { };
Add GNU Zile, a tiny Emacs clone. svn path=/nixpkgs/trunk/; revision=14249
2009-02-25 20:24:18 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
zip = callPackage ../tools/archivers/zip { };
* Added Xauth (pilfered from the modular X.org tree). svn path=/nixpkgs/trunk/; revision=3466
2005-07-29 11:06:49 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
zsync = callPackage ../tools/compression/zsync { };
* TightVNC. svn path=/nixpkgs/trunk/; revision=5698
2006-07-13 15:54:24 +01:00
* Updates paths in all-packages-generic.fix. svn path=/nixpkgs/trunk/; revision=472
2003-11-03 18:21:30 +00:00
### SHELLS
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
bash = lowPrio (callPackage ../shells/bash {
* Turn vim/default.nix into a regular package. We don't need two configurable VIMs. svn path=/nixpkgs/trunk/; revision=22784
2010-07-28 13:52:54 +01:00
texinfo = null;
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
});
* bash: updated to 4.0 patchlevel 17. Removed the dietlibc patch, we don't need it anymore. svn path=/nixpkgs/branches/stdenv-updates/; revision=15018
2009-04-13 19:38:45 +01:00
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
bashInteractive = appendToName "interactive" (callPackage ../shells/bash {
* Yes! Finally! Bash built with ncurses support! This fixes the annoying problem with lines longer than 80 (?) characters. svn path=/nixpkgs/trunk/; revision=8248
2007-03-06 22:46:03 +00:00
interactive = true;
* Delete some obsolete packages. * Make sure that every package in all-packages.nix has a unique name. Not all of them do, but there are now a few helper functions that modify the name of a package for display purposes in nix-env (e.g., you get "zlib-1.2.3" and "zlib-1.2.3-static" in "nix-env -qa"). svn path=/nixpkgs/trunk/; revision=8607
2007-04-26 14:02:30 +01:00
});
* Yes! Finally! Bash built with ncurses support! This fixes the annoying problem with lines longer than 80 (?) characters. svn path=/nixpkgs/trunk/; revision=8248
2007-03-06 22:46:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dash = callPackage ../shells/dash { };
* Added dash. svn path=/nixpkgs/trunk/; revision=22088
2010-06-01 18:05:29 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
tcsh = callPackage ../shells/tcsh { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
rush = callPackage ../shells/rush { };
Add GNU SASL, GNU GSS-API, and GNU Rush. Contributed by Brian Gough <bjg@gnu.org>. svn path=/nixpkgs/trunk/; revision=21315
2010-04-26 09:59:25 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
zsh = callPackage ../shells/zsh { };
Added zsh svn path=/nixpkgs/trunk/; revision=8900
2007-06-20 11:02:10 +01:00
* Updates paths in all-packages-generic.fix. svn path=/nixpkgs/trunk/; revision=472
2003-11-03 18:21:30 +00:00
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
### DEVELOPMENT / COMPILERS
* Updates paths in all-packages-generic.fix. svn path=/nixpkgs/trunk/; revision=472
2003-11-03 18:21:30 +00:00
* Converting packages. This is the minimal Nix stdenv for building the ATerm library. svn path=/nixpkgs/trunk/; revision=459
2003-11-02 17:42:19 +00:00
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
abc =
abcPatchable [];
add nixStatic and binutilsStatic svn path=/nixpkgs/trunk/; revision=6055
2006-08-05 12:02:17 +01:00
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
abcPatchable = patches :
* Remove redundant parentheses. svn path=/nixpkgs/trunk/; revision=6758
2006-10-18 11:32:45 +01:00
import ../development/compilers/abc/default.nix {
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01: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 17:26:58 +01:00
javaCup = callPackage ../development/libraries/java/cup { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
};
move binutils-arm to binutils-cross. Also, add binutils for mips-linux in a more generic way. Still, there is a lot of room for improvement. svn path=/nixpkgs/trunk/; revision=4458
2005-12-31 03:46:20 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
aspectj = callPackage ../development/compilers/aspectj { };
* Added patchelf. svn path=/nixpkgs/trunk/; revision=1505
2004-09-25 20:32:23 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
bigloo = callPackage ../development/compilers/bigloo { };
bigloo is now compiling svn path=/nixpkgs/trunk/; revision=10549
2008-02-08 01:35:01 +00:00
Added Clozure CL svn path=/nixpkgs/trunk/; revision=20211
2010-02-24 09:04:29 +00:00
ccl = builderDefsPackage ../development/compilers/ccl {};
Making clang build for llvm 2.7 (I've not tested the usage of c++ headers though, but it builds c and c++ simple programs) svn path=/nixpkgs/trunk/; revision=22236
2010-06-12 22:52:39 +01:00
clang = llvm.override {
buildClang = true;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
dylan = callPackage ../development/compilers/gwydion-dylan {
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
dylan =
import ../development/compilers/gwydion-dylan/binary.nix {
inherit fetchurl stdenv;
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
};
* A much newer version of flex. The old (GNU) one was from 1997. svn path=/nixpkgs/trunk/; revision=727
2004-01-30 10:10:06 +00:00
};
ECL entry in all-packages svn path=/nixpkgs/trunk/; revision=19556
2010-01-20 05:41:18 +00:00
ecl = builderDefsPackage ../development/compilers/ecl {
inherit gmp mpfr;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
adobe_flex_sdk = callPackage ../development/compilers/adobe-flex-sdk { };
adding open source adobe flex sdk svn path=/nixpkgs/trunk/; revision=14902
2009-04-06 14:07:21 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
fpc = callPackage ../development/compilers/fpc { };
Added Free Pascal Compiler. svn path=/nixpkgs/trunk/; revision=9102
2007-08-11 21:55:40 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gambit = callPackage ../development/compilers/gambit { };
Top-level entry for gambit commit svn path=/nixpkgs/trunk/; revision=22028
2010-05-28 07:08:50 +01:00
Switch to GCC 4.4. svn path=/nixpkgs/branches/stdenv-updates/; revision=18676
2009-11-27 17:59:03 +00:00
gcc = gcc44;
* Started adding gcc 3.4. svn path=/nixpkgs/trunk/; revision=1103
2004-06-29 09:25:55 +01:00
* Regularize the treatment of the "gcc" attributes in all-packages.nix. All "gcc*" attributes are wrapped GCC instances now. svn path=/nixpkgs/trunk/; revision=5671
2006-07-10 16:42:19 +01:00
gcc295 = wrapGCC (import ../development/compilers/gcc-2.95 {
inherit fetchurl stdenv noSysDirs;
});
gcc33 = wrapGCC (import ../development/compilers/gcc-3.3 {
inherit fetchurl stdenv noSysDirs;
});
gcc34 = wrapGCC (import ../development/compilers/gcc-3.4 {
inherit fetchurl stdenv noSysDirs;
});
Add GNU Texinfo 4.9, use it to produce GCC 4.x documentation. svn path=/nixpkgs/trunk/; revision=10805
2008-02-21 15:34:56 +00: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.
* g77 -> gfortran throughout. Got rid of the separate expressions/builders for Fortran. Tested by building Octave with gfortran 4.3. svn path=/nixpkgs/branches/stdenv-updates/; revision=14978
2009-04-09 16:24:33 +01:00
gcc40 = wrapGCC (makeOverridable (import ../development/compilers/gcc-4.0) {
* Regularize the treatment of the "gcc" attributes in all-packages.nix. All "gcc*" attributes are wrapped GCC instances now. svn path=/nixpkgs/trunk/; revision=5671
2006-07-10 16:42:19 +01:00
inherit fetchurl stdenv noSysDirs;
Add GNU Texinfo 4.9, use it to produce GCC 4.x documentation. svn path=/nixpkgs/trunk/; revision=10805
2008-02-21 15:34:56 +00:00
texinfo = texinfo49;
* Regularize the treatment of the "gcc" attributes in all-packages.nix. All "gcc*" attributes are wrapped GCC instances now. svn path=/nixpkgs/trunk/; revision=5671
2006-07-10 16:42:19 +01:00
profiledCompiler = true;
});
* g77 -> gfortran throughout. Got rid of the separate expressions/builders for Fortran. Tested by building Octave with gfortran 4.3. svn path=/nixpkgs/branches/stdenv-updates/; revision=14978
2009-04-09 16:24:33 +01:00
gcc41 = wrapGCC (makeOverridable (import ../development/compilers/gcc-4.1) {
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
inherit fetchurl stdenv noSysDirs;
Add GNU Texinfo 4.9, use it to produce GCC 4.x documentation. svn path=/nixpkgs/trunk/; revision=10805
2008-02-21 15:34:56 +00:00
texinfo = texinfo49;
* Put back in the code to do a profiled GCC build, but turn in off (build ICEs). svn path=/nixpkgs/trunk/; revision=6861
2006-10-26 21:23:49 +01:00
profiledCompiler = false;
* Default compiler changed to GCC 4.2.2. * Fix for NIXPKGS-60 ("g++ 4.2.0 cannot create dynamically linked executables"). svn path=/nixpkgs/branches/stdenv-updates/; revision=9691
2007-11-15 15:19:58 +00:00
});
* Get Wine to work (basically) by linking it against Glibc 2.6 with NPTL. Apparently Wine doesn't work with Glibc 2.5 + LinuxThreads. svn path=/nixpkgs/trunk/; revision=9165
2007-08-19 00:58:30 +01:00
* g77 -> gfortran throughout. Got rid of the separate expressions/builders for Fortran. Tested by building Octave with gfortran 4.3. svn path=/nixpkgs/branches/stdenv-updates/; revision=14978
2009-04-09 16:24:33 +01:00
gcc42 = wrapGCC (makeOverridable (import ../development/compilers/gcc-4.2) {
stub for gcc42 svn path=/nixpkgs/trunk/; revision=8718
2007-05-19 20:44:15 +01:00
inherit fetchurl stdenv noSysDirs;
* GCC 4.3.1. (g++ doesn't work yet though.) svn path=/nixpkgs/trunk/; revision=12194
2008-06-26 11:20:33 +01:00
profiledCompiler = false;
svn path=/nixpkgs/branches/stdenv-updates/; revision=12994
2008-10-07 18:34:35 +01:00
});
Improved support for building 32-bit binaries on x86_64-linux. * glibc_multi: a wrapper that combines the 32-bit and 64-bit Glibcs. This is necessary so that 64-bit GCC can find gnu/stubs-32.h and the 32-bit Glibc libraries. To build glibc_multi on x86_64-linux, you still need either the i686-linux Glibc derivation from a channel, or to have configured Nix with support for forwarding the build to a i686-linux machine. In the future this may become unnecessary by providing a prebuilt binary of 32-bit Glibc somewhere (like the binaries used in the stdenvLinux bootstrap). * With glibc_multi, it becomes possible to build gcc with multilib support (i.e. it builds 32-bit and 64-bit versions of libgcc, libstdc++, etc.). svn path=/nixpkgs/trunk/; revision=12203
2008-06-27 19:26:19 +01:00
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
gcc44 = gcc44_real;
* g77 -> gfortran throughout. Got rid of the separate expressions/builders for Fortran. Tested by building Octave with gfortran 4.3. svn path=/nixpkgs/branches/stdenv-updates/; revision=14978
2009-04-09 16:24:33 +01:00
Trying to get the gcc-4.4 cross-build also. Fixing the glibc-2.10 expression on cross-builds (which should be ported to the glibc-2.11 expression once we get "ports" there) Making kde3 and cyrus-sasl use gcc-4.3, because the strictness in gcc-4.4 does not allow them build. svn path=/nixpkgs/branches/stdenv-updates/; revision=18706
2009-11-29 23:27:35 +00: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 19:03:34 +00:00
inherit stdenv fetchurl texinfo gmp mpfr noSysDirs;
* Use GCC 4.3 by default. * Updated stdenv-linux: - The bootstrap tools are no longer statically linked (except for binaries in the Nixpkgs tree used to download and unpack the bootstrap tools). - x86_64 uses the same static binaries as i686. This makes the Nixpkgs tree a bit smaller. - Use the Linux 2.6.28 headers. svn path=/nixpkgs/branches/stdenv-updates/; revision=13946
2009-02-01 21:44:56 +00:00
profiledCompiler = true;
* nix-env -i gcc-wrapper matched two derivations, lower the priority of the second one. svn path=/nixpkgs/trunk/; revision=15972
2009-06-16 14:06:02 +01:00
}));
* Use GCC 4.3 by default. * Updated stdenv-linux: - The bootstrap tools are no longer statically linked (except for binaries in the Nixpkgs tree used to download and unpack the bootstrap tools). - x86_64 uses the same static binaries as i686. This makes the Nixpkgs tree a bit smaller. - Use the Linux 2.6.28 headers. svn path=/nixpkgs/branches/stdenv-updates/; revision=13946
2009-02-01 21:44:56 +00:00
I removed the function-shape of the cross-toolchain related attributes in the all-packages.nix. That was more complicating than helping. svn path=/nixpkgs/trunk/; revision=20457
2010-03-06 23:36:55 +00:00
gcc43_realCross = makeOverridable (import ../development/compilers/gcc-4.3) {
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 08:11:30 +00:00
profiledCompiler = false;
enableMultilib = true;
Cleaning a bit around gcc43_RealCross svn path=/nixpkgs/branches/stdenv-updates/; revision=18352
2009-11-15 05:39:22 +00:00
crossStageStatic = false;
Adding assertions for the cross-toolchain attributes, so noone feels tempted to build them without setting a crossSystem to build for. svn path=/nixpkgs/trunk/; revision=20459
2010-03-07 00:05:51 +00:00
cross = assert crossSystem != null; crossSystem;
Fixing many things related to the cross compilation in stdenvCross. It still does not work, but I think I already get glibc cross compiled. Next: gcc and g++, and set some setup script hooks on stdenvCross. It took quite enough hours for this commit. svn path=/nixpkgs/branches/stdenv-updates/; revision=18351
2009-11-15 05:28:35 +00:00
};
Trying to remove more hydra evaluation errors related to gcc. svn path=/nixpkgs/trunk/; revision=20687
2010-03-17 10:17:32 +00:00
gcc44_realCross = lib.addMetaAttrs { platforms = []; }
(makeOverridable (import ../development/compilers/gcc-4.4) {
Trying to remove evaluation errors in hydra nixpkgs for the cross compiler related derivations. I remove their 'meta platforms' attribute, defined in the gcc expression, so hydra does not attempt to build them in the nixpkgs evaluation. svn path=/nixpkgs/trunk/; revision=20678
2010-03-17 09:05:11 +00:00
inherit stdenv fetchurl texinfo gmp mpfr ppl cloogppl noSysDirs
gettext which;
binutilsCross = binutilsCross;
libcCross = libcCross;
profiledCompiler = false;
enableMultilib = false;
crossStageStatic = false;
cross = assert crossSystem != null; crossSystem;
});
Trying to get the gcc-4.4 cross-build also. Fixing the glibc-2.10 expression on cross-builds (which should be ported to the glibc-2.11 expression once we get "ports" there) Making kde3 and cyrus-sasl use gcc-4.3, because the strictness in gcc-4.4 does not allow them build. svn path=/nixpkgs/branches/stdenv-updates/; revision=18706
2009-11-29 23:27:35 +00:00
Adding the expressions for gcc 4.5 for cross building. Although I still have set gcc 4.4 for that, I tested with the 4.5 expression and it cross built perfectly bison for the sheevaplug. svn path=/nixpkgs/trunk/; revision=21463
2010-04-30 20:12:59 +01:00
gcc45_realCross = lib.addMetaAttrs { platforms = []; }
(makeOverridable (import ../development/compilers/gcc-4.5) {
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;
});
Making gcc-4.5 cross-build to mingw32 too (set by the proper config and libc = "msvcrt" in the crossSystem) svn path=/nixpkgs/trunk/; revision=21630
2010-05-06 19:22:51 +01:00
gcc_realCross = gcc45_realCross;
gccCrossStageStatic = let
isMingw = (stdenv.cross.libc == "msvcrt");
Making wxGTK stay wxGTK even cross-built, so I remove the wxMSW code I added to test the crossbuilding with wxGTK. I added a new windows-specific package: wxMSW. svn path=/nixpkgs/trunk/; revision=21634
2010-05-06 20:19:22 +01:00
libcCross1 = if isMingw then windows.mingw_headers1 else null;
Making gcc-4.5 cross-build to mingw32 too (set by the proper config and libc = "msvcrt" in the crossSystem) svn path=/nixpkgs/trunk/; revision=21630
2010-05-06 19:22:51 +01: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;
Making wxGTK stay wxGTK even cross-built, so I remove the wxMSW code I added to test the crossbuilding with wxGTK. I added a new windows-specific package: wxMSW. svn path=/nixpkgs/trunk/; revision=21634
2010-05-06 20:19:22 +01:00
libc = windows.mingw_headers2;
I removed the function-shape of the cross-toolchain related attributes in the all-packages.nix. That was more complicating than helping. svn path=/nixpkgs/trunk/; revision=20457
2010-03-06 23:36:55 +00:00
binutils = binutilsCross;
Adding assertions for the cross-toolchain attributes, so noone feels tempted to build them without setting a crossSystem to build for. svn path=/nixpkgs/trunk/; revision=20459
2010-03-07 00:05:51 +00: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 08:11:30 +00:00
};
I removed the function-shape of the cross-toolchain related attributes in the all-packages.nix. That was more complicating than helping. svn path=/nixpkgs/trunk/; revision=20457
2010-03-06 23:36:55 +00:00
gccCrossStageFinal = wrapGCCCross {
GCC 4.5: Add support for a separate libpthread; rearrange target flags handling. svn path=/nixpkgs/trunk/; revision=21905
2010-05-19 22:32:19 +01:00
gcc = forceBuildDrv (gcc_realCross.override {
libpthreadCross =
# FIXME: Don't explicitly refer to `i586-pc-gnu'.
if crossSystem != null && crossSystem.config == "i586-pc-gnu"
then hurdLibpthreadCross
else null;
});
I removed the function-shape of the cross-toolchain related attributes in the all-packages.nix. That was more complicating than helping. svn path=/nixpkgs/trunk/; revision=20457
2010-03-06 23:36:55 +00:00
libc = libcCross;
binutils = binutilsCross;
Adding assertions for the cross-toolchain attributes, so noone feels tempted to build them without setting a crossSystem to build for. svn path=/nixpkgs/trunk/; revision=20459
2010-03-07 00:05:51 +00:00
cross = assert crossSystem != null; crossSystem;
Fixing many things related to the cross compilation in stdenvCross. It still does not work, but I think I already get glibc cross compiled. Next: gcc and g++, and set some setup script hooks on stdenvCross. It took quite enough hours for this commit. svn path=/nixpkgs/branches/stdenv-updates/; revision=18351
2009-11-15 05:28:35 +00: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 08:11:30 +00:00
Trying to get the gcc-4.4 cross-build also. Fixing the glibc-2.10 expression on cross-builds (which should be ported to the glibc-2.11 expression once we get "ports" there) Making kde3 and cyrus-sasl use gcc-4.3, because the strictness in gcc-4.4 does not allow them build. svn path=/nixpkgs/branches/stdenv-updates/; revision=18706
2009-11-29 23:27:35 +00:00
gcc43_multi = lowPrio (wrapGCCWith (import ../build-support/gcc-wrapper) glibc_multi (gcc43.gcc.override {
svn path=/nixpkgs/branches/stdenv-updates/; revision=14844
2009-04-02 20:55:57 +01:00
stdenv = overrideGCC stdenv (wrapGCCWith (import ../build-support/gcc-wrapper) glibc_multi gcc);
Improved support for building 32-bit binaries on x86_64-linux. * glibc_multi: a wrapper that combines the 32-bit and 64-bit Glibcs. This is necessary so that 64-bit GCC can find gnu/stubs-32.h and the 32-bit Glibc libraries. To build glibc_multi on x86_64-linux, you still need either the i686-linux Glibc derivation from a channel, or to have configured Nix with support for forwarding the build to a i686-linux machine. In the future this may become unnecessary by providing a prebuilt binary of 32-bit Glibc somewhere (like the binaries used in the stdenvLinux bootstrap). * With glibc_multi, it becomes possible to build gcc with multilib support (i.e. it builds 32-bit and 64-bit versions of libgcc, libstdc++, etc.). svn path=/nixpkgs/trunk/; revision=12203
2008-06-27 19:26:19 +01:00
profiledCompiler = false;
enableMultilib = true;
* GCC 4.3.1. (g++ doesn't work yet though.) svn path=/nixpkgs/trunk/; revision=12194
2008-06-26 11:20:33 +01:00
}));
Trying to get the gcc-4.4 cross-build also. Fixing the glibc-2.10 expression on cross-builds (which should be ported to the glibc-2.11 expression once we get "ports" there) Making kde3 and cyrus-sasl use gcc-4.3, because the strictness in gcc-4.4 does not allow them build. svn path=/nixpkgs/branches/stdenv-updates/; revision=18706
2009-11-29 23:27:35 +00:00
gcc44_real = lowPrio (wrapGCC (makeOverridable (import ../development/compilers/gcc-4.4) {
* Disable Graphite in GCC, as discussed on the mailing list. svn path=/nixpkgs/branches/stdenv-updates/; revision=19547
2010-01-19 17:10:53 +00:00
inherit fetchurl stdenv texinfo gmp mpfr /* ppl cloogppl */
GCJ 4.4: Provide InfoZIP; remove FastJar hack; don't build C; provide which(1). svn path=/nixpkgs/trunk/; revision=16475
2009-07-27 16:40:01 +01:00
gettext which noSysDirs;
Add GCC 4.4.0 (and hope for the best). svn path=/nixpkgs/trunk/; revision=16168
2009-07-03 19:54:28 +01:00
profiledCompiler = true;
* GCC 4.3 should be the default. svn path=/nixpkgs/trunk/; revision=17368
2009-09-23 19:33:40 +01:00
}));
Add GCC 4.4.0 (and hope for the best). svn path=/nixpkgs/trunk/; revision=16168
2009-07-03 19:54:28 +01:00
GCC 4.5.0. svn path=/nixpkgs/trunk/; revision=21403
2010-04-28 13:37:11 +01:00
gcc45 = lowPrio (wrapGCC (makeOverridable (import ../development/compilers/gcc-4.5) {
GCC 4.5: Add dependency on Perl. svn path=/nixpkgs/trunk/; revision=21974
2010-05-25 20:38:18 +01:00
inherit fetchurl stdenv texinfo gmp mpfr mpc libelf zlib perl
GCC 4.5.0. svn path=/nixpkgs/trunk/; revision=21403
2010-04-28 13:37:11 +01:00
ppl cloogppl
gettext which noSysDirs;
profiledCompiler = true;
}));
pkgs/applications/editors/emacs-modes/prolog: initial version of prolog-mode for Emacs svn path=/nixpkgs/trunk/; revision=18675
2009-11-27 17:40:56 +00:00
gccApple =
changes for x86_64-darwin support svn path=/nixpkgs/trunk/; revision=18667
2009-11-27 10:56:07 +00:00
wrapGCC ( (if stdenv.system == "i686-darwin" then import ../development/compilers/gcc-apple else import ../development/compilers/gcc-apple64) {
inherit fetchurl stdenv noSysDirs;
profiledCompiler = true;
}) ;
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
Add GCC-UPC, a compiler for the UPC distributed shared memory language. svn path=/nixpkgs/trunk/; revision=10956
2008-03-04 16:20:11 +00:00
gccupc40 = wrapGCCUPC (import ../development/compilers/gcc-upc-4.0 {
inherit fetchurl stdenv bison autoconf gnum4 noSysDirs;
texinfo = texinfo49;
});
* g77 -> gfortran throughout. Got rid of the separate expressions/builders for Fortran. Tested by building Octave with gfortran 4.3. svn path=/nixpkgs/branches/stdenv-updates/; revision=14978
2009-04-09 16:24:33 +01:00
gfortran = gfortran43;
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;
});
Trying to get the gcc-4.4 cross-build also. Fixing the glibc-2.10 expression on cross-builds (which should be ported to the glibc-2.11 expression once we get "ports" there) Making kde3 and cyrus-sasl use gcc-4.3, because the strictness in gcc-4.4 does not allow them build. svn path=/nixpkgs/branches/stdenv-updates/; revision=18706
2009-11-29 23:27:35 +00:00
gfortran43 = wrapGCC (gcc43.gcc.override {
* g77 -> gfortran throughout. Got rid of the separate expressions/builders for Fortran. Tested by building Octave with gfortran 4.3. svn path=/nixpkgs/branches/stdenv-updates/; revision=14978
2009-04-09 16:24:33 +01:00
name = "gfortran";
langFortran = true;
langCC = false;
langC = false;
profiledCompiler = false;
});
* Fix some evaluation errors. * Removed glibc 2.10. svn path=/nixpkgs/trunk/; revision=20130
2010-02-19 15:40:37 +00:00
gfortran44 = wrapGCC (gcc44_real.gcc.override {
Add `gfortran44'; build GCJ 4.4 with the C language. svn path=/nixpkgs/trunk/; revision=16459
2009-07-24 23:19:07 +01:00
name = "gfortran";
langFortran = true;
langCC = false;
langC = false;
profiledCompiler = false;
});
Make GCJ 4.5 the default GCJ. svn path=/nixpkgs/trunk/; revision=21989
2010-05-26 15:53:09 +01:00
gcj = gcj45;
An attempt to add gcj-4.3. It fails not finding some GC-related symbols. I failed to understand the reason - for now svn path=/nixpkgs/trunk/; revision=15523
2009-05-10 10:11:41 +01:00
* Fix some evaluation errors. * Removed glibc 2.10. svn path=/nixpkgs/trunk/; revision=20130
2010-02-19 15:40:37 +00:00
gcj44 = wrapGCC (gcc44_real.gcc.override {
Add GCC 4.4.0 (and hope for the best). svn path=/nixpkgs/trunk/; revision=16168
2009-07-03 19:54:28 +01:00
name = "gcj";
langJava = true;
langFortran = false;
langCC = true;
GCJ 4.4: Provide InfoZIP; remove FastJar hack; don't build C; provide which(1). svn path=/nixpkgs/trunk/; revision=16475
2009-07-27 16:40:01 +01:00
langC = false;
Add GCC 4.4.0 (and hope for the best). svn path=/nixpkgs/trunk/; revision=16168
2009-07-03 19:54:28 +01:00
profiledCompiler = false;
GCJ 4.4: Build the GTK+ AWT peer. svn path=/nixpkgs/trunk/; revision=16487
2009-07-28 09:11:10 +01:00
inherit zip unzip zlib boehmgc gettext pkgconfig;
inherit (gtkLibs) gtk;
GCJ 4.4: Require libart. svn path=/nixpkgs/trunk/; revision=16490
2009-07-28 10:23:40 +01:00
inherit (gnome) libart_lgpl;
GCJ 4.4: Fix missing <X11/extensions/XInput.h> by adding `libXi'. That header used to be provided by inputproto-1.4 but is no longer provided by inputproto-2.0. svn path=/nixpkgs/trunk/; revision=18164
2009-11-05 21:43:00 +00:00
inherit (xlibs) libX11 libXt libSM libICE libXtst libXi libXrender
GCJ 4.4: More X dependencies. svn path=/nixpkgs/trunk/; revision=16516
2009-07-30 09:32:43 +01:00
libXrandr xproto renderproto xextproto inputproto randrproto;
Add GCC 4.4.0 (and hope for the best). svn path=/nixpkgs/trunk/; revision=16168
2009-07-03 19:54:28 +01:00
});
GCC 4.5.0. svn path=/nixpkgs/trunk/; revision=21403
2010-04-28 13:37:11 +01:00
gcj45 = wrapGCC (gcc45.gcc.override {
name = "gcj";
langJava = true;
langFortran = false;
langCC = true;
langC = false;
profiledCompiler = false;
GCJ 4.5: Build with `--enable-java-home' & co. svn path=/nixpkgs/trunk/; revision=21973
2010-05-25 20:38:13 +01:00
inherit zip unzip zlib boehmgc gettext pkgconfig perl;
GCC 4.5.0. svn path=/nixpkgs/trunk/; revision=21403
2010-04-28 13:37:11 +01:00
inherit (gtkLibs) gtk;
inherit (gnome) libart_lgpl;
inherit (xlibs) libX11 libXt libSM libICE libXtst libXi libXrender
libXrandr xproto renderproto xextproto inputproto randrproto;
});
Adding first built version of the gnat compiler for gcc 4.4. Some things don't work: - The ghdl expression (it still needs the gcc 4.3.4 src, ...) - The gnat wrappers need to be more generic - now they work only for the given gnatboot (taken from gentoo) and gnats installed to their $out store path. - Using the cloogppl and ppl. We will need our own gnatboot built with c++ libraries for that. svn path=/nixpkgs/branches/stdenv-updates/; revision=19060
2009-12-21 07:49:31 +00:00
gnat = gnat44;
Merging the gnat-wrapper and gcc-wrapper into a single gcc-wrapper. (I will remove the gnat-wrapper files if this works, later) svn path=/nixpkgs/branches/stdenv-updates/; revision=19492
2010-01-16 21:32:44 +00:00
gnat44 = wrapGCC (gcc44_real.gcc.override {
Adding first built version of the gnat compiler for gcc 4.4. Some things don't work: - The ghdl expression (it still needs the gcc 4.3.4 src, ...) - The gnat wrappers need to be more generic - now they work only for the given gnatboot (taken from gentoo) and gnats installed to their $out store path. - Using the cloogppl and ppl. We will need our own gnatboot built with c++ libraries for that. svn path=/nixpkgs/branches/stdenv-updates/; revision=19060
2009-12-21 07:49:31 +00: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;
});
Merging the gnat-wrapper and gcc-wrapper into a single gcc-wrapper. (I will remove the gnat-wrapper files if this works, later) svn path=/nixpkgs/branches/stdenv-updates/; revision=19492
2010-01-16 21:32:44 +00:00
gnatboot = wrapGCC (import ../development/compilers/gnatboot {
Adding first built version of the gnat compiler for gcc 4.4. Some things don't work: - The ghdl expression (it still needs the gcc 4.3.4 src, ...) - The gnat wrappers need to be more generic - now they work only for the given gnatboot (taken from gentoo) and gnats installed to their $out store path. - Using the cloogppl and ppl. We will need our own gnatboot built with c++ libraries for that. svn path=/nixpkgs/branches/stdenv-updates/; revision=19060
2009-12-21 07:49:31 +00:00
inherit fetchurl stdenv;
});
Merging the ghdl-wrapper and gcc-wrapper into one. I will remove the ghdl-wrapper files later, if all this works. svn path=/nixpkgs/branches/stdenv-updates/; revision=19493
2010-01-16 21:41:27 +00:00
ghdl = wrapGCC (import ../development/compilers/gcc-4.3 {
Getting a new gcc-wrapper on the way. After gnat-wrapper, I introduce ghdl-wrapper. I made the gcc-4.3.4 expression allow the 'vhdl' language through ghdl. The ghdl developer recommends this gcc version; maybe it would work with gcc-4.4. If not this ghdl version, maybe next versions. svn path=/nixpkgs/branches/stdenv-updates/; revision=19071
2009-12-21 23:02:06 +00:00
inherit stdenv fetchurl texinfo gmp mpfr noSysDirs gnat;
Moving most of the ghdl logic outside the middle of the gcc expression. Agreed on a final naming logic for the ghdl package: ghdl-wrapper-0.29 svn path=/nixpkgs/branches/stdenv-updates/; revision=19450
2010-01-14 23:03:31 +00:00
name = "ghdl";
Getting a new gcc-wrapper on the way. After gnat-wrapper, I introduce ghdl-wrapper. I made the gcc-4.3.4 expression allow the 'vhdl' language through ghdl. The ghdl developer recommends this gcc version; maybe it would work with gcc-4.4. If not this ghdl version, maybe next versions. svn path=/nixpkgs/branches/stdenv-updates/; revision=19071
2009-12-21 23:02:06 +00:00
langVhdl = true;
langCC = false;
langC = false;
profiledCompiler = false;
enableMultilib = false;
});
Updating the ghdl related expressions: - Adding ghdl with gcc 4.4 (with a patch I built for it to work) - Adding me as maintainer to both gccs and ghdl svn path=/nixpkgs/branches/stdenv-updates/; revision=19475
2010-01-15 23:22:28 +00:00
# Not officially supported version for ghdl
Merging the ghdl-wrapper and gcc-wrapper into one. I will remove the ghdl-wrapper files later, if all this works. svn path=/nixpkgs/branches/stdenv-updates/; revision=19493
2010-01-16 21:41:27 +00:00
ghdl_gcc44 = lowPrio (wrapGCC (import ../development/compilers/gcc-4.4 {
Updating the ghdl related expressions: - Adding ghdl with gcc 4.4 (with a patch I built for it to work) - Adding me as maintainer to both gccs and ghdl svn path=/nixpkgs/branches/stdenv-updates/; revision=19475
2010-01-15 23:22:28 +00: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;
}));
Fix wxGTK reference for xchm svn path=/nixpkgs/trunk/; revision=18156
2009-11-05 21:08:53 +00:00
gcl = builderDefsPackage ../development/compilers/gcl {
pkgs/top-level/all-packages.nix: stripped trailing whitespace svn path=/nixpkgs/trunk/; revision=22734
2010-07-26 14:41:09 +01:00
inherit mpfr m4 binutils fetchcvs emacs zlib which
Oops, pass needed args svn path=/nixpkgs/trunk/; revision=22542
2010-07-09 05:24:31 +01:00
gmp texinfo;
pkgs/applications/editors/emacs-modes/prolog: initial version of prolog-mode for Emacs svn path=/nixpkgs/trunk/; revision=18675
2009-11-27 17:40:56 +00:00
inherit (xlibs) libX11 xproto inputproto libXi
Try using latest CLisp for SBCL in case SBCL fixed compatibility issues svn path=/nixpkgs/trunk/; revision=18184
2009-11-06 07:39:59 +00:00
libXext xextproto libXt libXaw libXmu;
Apparently fixed GCL build svn path=/nixpkgs/trunk/; revision=22498
2010-07-06 17:48:03 +01:00
inherit stdenv;
Oops, pass needed args svn path=/nixpkgs/trunk/; revision=22542
2010-07-09 05:24:31 +01:00
texLive = texLiveAggregationFun {
paths = [
texLive texLiveExtra
];
};
Fix wxGTK reference for xchm svn path=/nixpkgs/trunk/; revision=18156
2009-11-05 21:08:53 +00:00
};
Added GHC HEAD snapshot. svn path=/nixpkgs/trunk/; revision=17227
2009-09-17 12:45:20 +01:00
# GHC
# GHC binaries are around for bootstrapping purposes
Some cleanup regarding GHC and profiling support. svn path=/nixpkgs/trunk/; revision=21351
2010-04-27 19:21:07 +01: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.
commenting older ghc's they can't be compiled due to realdine and linking issues. I'm not willing to fix them right now. svn path=/nixpkgs/trunk/; revision=18900
2009-12-11 13:58:41 +00:00
/*
* Build GHC 6.8 and 6.10 in Hydra. * Make GHC 6.10.2 the default. svn path=/nixpkgs/trunk/; revision=15107
2009-04-16 23:06:33 +01:00
ghc642Binary = lowPrio (import ../development/compilers/ghc/6.4.2-binary.nix {
inherit fetchurl stdenv ncurses gmp;
fix build of ghc-6.8.2 svn path=/nixpkgs/trunk/; revision=18899
2009-12-11 13:58:36 +00:00
readline = if stdenv.system == "i686-linux" then readline4 else readline5;
* Build GHC 6.8 and 6.10 in Hydra. * Make GHC 6.10.2 the default. svn path=/nixpkgs/trunk/; revision=15107
2009-04-16 23:06:33 +01:00
perl = perl58;
});
commenting older ghc's they can't be compiled due to realdine and linking issues. I'm not willing to fix them right now. svn path=/nixpkgs/trunk/; revision=18900
2009-12-11 13:58:41 +00:00
*/
* adding ghc-6.8 even though it still segfaults on my machine (it's marked lowPrio for now, so it shouldn't break anything) svn path=/nixpkgs/trunk/; revision=9482
2007-10-19 14:24:29 +01:00
* Revert to GHC 6.10.1 binary for bootstrapping GHC 6.10.2 at Andres' suggestion. It's good to use an older GHC for bootstrapping because old versions can build newer versions but not vice versa. svn path=/nixpkgs/trunk/; revision=15120
2009-04-17 20:43:05 +01:00
ghc6101Binary = lowPrio (import ../development/compilers/ghc/6.10.1-binary.nix {
inherit fetchurl stdenv perl ncurses gmp libedit;
});
Added a ghc-6.8.3 snapshot (with version number 6.8.2.20080602). svn path=/nixpkgs/trunk/; revision=11969
2008-06-04 10:42:25 +01:00
* Added GHC 6.10.2. svn path=/nixpkgs/trunk/; revision=15106
2009-04-16 23:00:41 +01:00
ghc6102Binary = lowPrio (import ../development/compilers/ghc/6.10.2-binary.nix {
* GHC apparently works with Perl 5.10 now. svn path=/nixpkgs/trunk/; revision=15101
2009-04-16 20:59:41 +01:00
inherit fetchurl stdenv perl ncurses gmp libedit;
* ghc-6.9 should have low priority svn path=/nixpkgs/trunk/; revision=12430
2008-07-25 15:21:54 +01:00
});
* Added ghc-6.8.3 as the new default version of ghc. * Added a ghc HEAD snapshot (ghc-6.9.x). svn path=/nixpkgs/trunk/; revision=12391
2008-07-21 15:43:33 +01:00
Added GHC HEAD snapshot. svn path=/nixpkgs/trunk/; revision=17227
2009-09-17 12:45:20 +01:00
# For several compiler versions, we export a large set of Haskell-related
# packages.
Some cleanup regarding GHC and profiling support. svn path=/nixpkgs/trunk/; revision=21351
2010-04-27 19:21:07 +01:00
# This should point to the current default version.
Switched the default version of ghc and Haskell Platform to 6.12.3 and 2010.2.0.0. svn path=/nixpkgs/trunk/; revision=22715
2010-07-22 19:47:59 +01:00
haskellPackages = haskellPackages_ghc6123;
* Move the composition of Haskell packages out of all-packages.nix into haskell-packages.nix, which depends on an instance of GHC. This allows a consistent set of packages to be built with the same GHC. For instance, $ nix-build -A haskellPackages_ghc683.xmonad builds xmonad and all its dependencies with GHC 6.8.3, while $ nix-build -A haskellPackages_ghc6102.xmonad does the same with GHC 6.10.2. This is the same technique used with kernelPackages. It also means that we don't need things like "cabal682" and "cabal683" anymore. * The setup hook is now in a separate wrapper package so that we don't have to recompile all of GHC every time we want to make a small change. * cinelerra: this package appears to have an accidental dependency on the "X11" Haskell package. svn path=/nixpkgs/trunk/; revision=15125
2009-04-18 13:47:11 +01:00
Some cleanup regarding GHC and profiling support. svn path=/nixpkgs/trunk/; revision=21351
2010-04-27 19:21:07 +01:00
# Old versions of ghc that currently don't build because the binary
# is broken.
commenting older ghc's they can't be compiled due to realdine and linking issues. I'm not willing to fix them right now. svn path=/nixpkgs/trunk/; revision=18900
2009-12-11 13:58:41 +00:00
/*
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
haskellPackages_ghc642 = callPackage ./haskell-packages.nix {
* Move the remaining GHC-dependent packages to haskell-packages.nix. svn path=/nixpkgs/trunk/; revision=15144
2009-04-19 11:27:22 +01:00
ghc = import ../development/compilers/ghc/6.4.2.nix {
inherit fetchurl stdenv perl ncurses readline m4 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 17:26:58 +01:00
ghc = ghc642Binary; };
* ghc version 6.6.1 svn path=/nixpkgs/trunk/; revision=8654
2007-05-06 16:39:39 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
haskellPackages_ghc661 = callPackage ./haskell-packages.nix {
* Move the remaining GHC-dependent packages to haskell-packages.nix. svn path=/nixpkgs/trunk/; revision=15144
2009-04-19 11:27:22 +01:00
ghc = import ../development/compilers/ghc/6.6.1.nix {
inherit fetchurl stdenv readline perl58 gmp ncurses m4;
ghc = ghc642Binary;
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
};
Added GHC 6.6. note: the old GHC 6.4(.2?) version is still there. I reused the bootstrap-version to bootstrap GHC-6.6. And some other packages depend on the old GHC version as well. note: only use this package for building other packages. If you install it as an end-user, you'll only be able to use the default GHC libraries, because other libraries are only privately registered to this GHC version during a nix-build by hooks (which are not executed when you run GHC yourself as an end-user). Consequently, also added a newer version of uulib and uuagc. svn path=/nixpkgs/trunk/; revision=7346
2006-12-15 13:32:55 +00:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
haskellPackages_ghc682 = callPackage ./haskell-packages.nix {
* Move the remaining GHC-dependent packages to haskell-packages.nix. svn path=/nixpkgs/trunk/; revision=15144
2009-04-19 11:27:22 +01:00
ghc = import ../development/compilers/ghc/6.8.2.nix {
fix build of ghc-6.8.2 svn path=/nixpkgs/trunk/; revision=18899
2009-12-11 13:58:36 +00:00
inherit fetchurl stdenv perl gmp ncurses m4;
readline = readline5;
* Move the remaining GHC-dependent packages to haskell-packages.nix. svn path=/nixpkgs/trunk/; revision=15144
2009-04-19 11:27:22 +01:00
ghc = ghc642Binary;
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
};
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
};
all-packages.nix: commented out package 'vice' error: getting status of `/usr/local/src/nix-pkgs-current/pkgs/misc/emulators/vice': No such file or directory svn path=/nixpkgs/trunk/; revision=15646
2009-05-18 14:53:01 +01:00
* Move the remaining GHC-dependent packages to haskell-packages.nix. svn path=/nixpkgs/trunk/; revision=15144
2009-04-19 11:27:22 +01:00
haskellPackages_ghc683 = recurseIntoAttrs (import ./haskell-packages.nix {
inherit pkgs;
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
ghc = callPackage ../development/compilers/ghc/6.8.3.nix {
* Move the remaining GHC-dependent packages to haskell-packages.nix. svn path=/nixpkgs/trunk/; revision=15144
2009-04-19 11:27:22 +01:00
ghc = ghc642Binary;
haddock = import ../development/tools/documentation/haddock/boot.nix {
inherit gmp;
cabal = import ../development/libraries/haskell/cabal/cabal.nix {
* Fix GHC 6.8.3. svn path=/nixpkgs/trunk/; revision=15285
2009-04-23 19:44:52 +01:00
inherit stdenv fetchurl lib;
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ghc = ghc642Binary; };
* Move the remaining GHC-dependent packages to haskell-packages.nix. svn path=/nixpkgs/trunk/; revision=15144
2009-04-19 11:27:22 +01:00
};
};
});
commenting older ghc's they can't be compiled due to realdine and linking issues. I'm not willing to fix them right now. svn path=/nixpkgs/trunk/; revision=18900
2009-12-11 13:58:41 +00:00
*/
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
Commented on the current decision on recurseIntoAttrs for haskellPackages. svn path=/nixpkgs/trunk/; revision=21478
2010-05-01 12:23:39 +01:00
# NOTE: After discussion, we decided to enable recurseIntoAttrs for all
# currently available ghc versions. (Before, it used to be enabled only
# for a selected few versions.) If someone complains about nix-env -qa
# output being spammed by lots of Haskell packages, we can talk about
# reducing the number or "enabled" versions again.
Some cleanup regarding GHC and profiling support. svn path=/nixpkgs/trunk/; revision=21351
2010-04-27 19:21:07 +01:00
# Helper functions to abstract away from repetitive instantiations.
Making the latest haskell expressions appear on 'nix-env -qa'. More than one person had trouble not finding ghc 6.12 on 'nix-env -qa '*'' svn path=/nixpkgs/trunk/; revision=21477
2010-05-01 11:55:05 +01:00
haskellPackagesFun610 = ghcPath : profDefault : recurseIntoAttrs (import ./haskell-packages.nix {
* Added GHC 6.10.1. svn path=/nixpkgs/trunk/; revision=15147
2009-04-19 12:43:38 +01:00
inherit pkgs;
Some cleanup regarding GHC and profiling support. svn path=/nixpkgs/trunk/; revision=21351
2010-04-27 19:21:07 +01:00
enableLibraryProfiling = getConfig [ "cabal" "libraryProfiling" ] profDefault;
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
ghc = callPackage ghcPath {
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ghc = ghc6101Binary; };
Making the latest haskell expressions appear on 'nix-env -qa'. More than one person had trouble not finding ghc 6.12 on 'nix-env -qa '*'' svn path=/nixpkgs/trunk/; revision=21477
2010-05-01 11:55:05 +01:00
});
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
Making the latest haskell expressions appear on 'nix-env -qa'. More than one person had trouble not finding ghc 6.12 on 'nix-env -qa '*'' svn path=/nixpkgs/trunk/; revision=21477
2010-05-01 11:55:05 +01:00
haskellPackagesFun612 = ghcPath : profDefault : recurseIntoAttrs (import ./haskell-packages.nix {
* Move the remaining GHC-dependent packages to haskell-packages.nix. svn path=/nixpkgs/trunk/; revision=15144
2009-04-19 11:27:22 +01:00
inherit pkgs;
Some cleanup regarding GHC and profiling support. svn path=/nixpkgs/trunk/; revision=21351
2010-04-27 19:21:07 +01:00
enableLibraryProfiling = getConfig [ "cabal" "libraryProfiling" ] profDefault;
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
ghc = callPackage ghcPath {
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ghc = ghc6101Binary; };
Making the latest haskell expressions appear on 'nix-env -qa'. More than one person had trouble not finding ghc 6.12 on 'nix-env -qa '*'' svn path=/nixpkgs/trunk/; revision=21477
2010-05-01 11:55:05 +01:00
});
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
Some cleanup regarding GHC and profiling support. svn path=/nixpkgs/trunk/; revision=21351
2010-04-27 19:21:07 +01:00
# Currently active GHC versions.
haskellPackages_ghc6101 =
haskellPackagesFun610 ../development/compilers/ghc/6.10.1.nix false;
Added ghc-6.10.3. svn path=/nixpkgs/trunk/; revision=15541
2009-05-10 22:04:58 +01:00
Some cleanup regarding GHC and profiling support. svn path=/nixpkgs/trunk/; revision=21351
2010-04-27 19:21:07 +01:00
haskellPackages_ghc6102 =
haskellPackagesFun610 ../development/compilers/ghc/6.10.2.nix false;
Version bump to ghc-6.10.4. svn path=/nixpkgs/trunk/; revision=16430
2009-07-20 14:02:56 +01:00
Some cleanup regarding GHC and profiling support. svn path=/nixpkgs/trunk/; revision=21351
2010-04-27 19:21:07 +01:00
haskellPackages_ghc6103 =
haskellPackagesFun610 ../development/compilers/ghc/6.10.3.nix false;
Added ghc-6.12.1 release candidate. svn path=/nixpkgs/trunk/; revision=17824
2009-10-15 13:49:37 +01:00
Commented on the current decision on recurseIntoAttrs for haskellPackages. svn path=/nixpkgs/trunk/; revision=21478
2010-05-01 12:23:39 +01:00
# Current default version.
haskellPackages_ghc6104 =
haskellPackagesFun610 ../development/compilers/ghc/6.10.4.nix false;
Some cleanup regarding GHC and profiling support. svn path=/nixpkgs/trunk/; revision=21351
2010-04-27 19:21:07 +01:00
Switched the default version of ghc and Haskell Platform to 6.12.3 and 2010.2.0.0. svn path=/nixpkgs/trunk/; revision=22715
2010-07-22 19:47:59 +01:00
haskellPackages_ghc6121 =
haskellPackagesFun612 ../development/compilers/ghc/6.12.1.nix false;
Some cleanup regarding GHC and profiling support. svn path=/nixpkgs/trunk/; revision=21351
2010-04-27 19:21:07 +01:00
Switched the default version of ghc and Haskell Platform to 6.12.3 and 2010.2.0.0. svn path=/nixpkgs/trunk/; revision=22715
2010-07-22 19:47:59 +01:00
haskellPackages_ghc6122 =
haskellPackagesFun612 ../development/compilers/ghc/6.12.2.nix false;
Added ghc-6.12.2. svn path=/nixpkgs/trunk/; revision=21303
2010-04-25 18:27:21 +01:00
Switched the default version of ghc and Haskell Platform to 6.12.3 and 2010.2.0.0. svn path=/nixpkgs/trunk/; revision=22715
2010-07-22 19:47:59 +01:00
haskellPackages_ghc6123 =
haskellPackagesFun612 ../development/compilers/ghc/6.12.3.nix false;
Added ghc-6.12.3. Does not build yet for me -- still have to figure out why. svn path=/nixpkgs/trunk/; revision=22525
2010-07-08 12:43:06 +01:00
Some cleanup regarding GHC and profiling support. svn path=/nixpkgs/trunk/; revision=21351
2010-04-27 19:21:07 +01:00
# Currently not pointing to the actual HEAD, therefore disabled
Added ghc-6.12.2. svn path=/nixpkgs/trunk/; revision=21303
2010-04-25 18:27:21 +01:00
/*
haskellPackages_ghcHEAD = lowPrio (import ./haskell-packages.nix {
Added GHC HEAD snapshot. svn path=/nixpkgs/trunk/; revision=17227
2009-09-17 12:45:20 +01:00
inherit pkgs;
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
ghc = callPackage ../development/compilers/ghc/6.11.nix {
Added GHC HEAD snapshot. svn path=/nixpkgs/trunk/; revision=17227
2009-09-17 12:45:20 +01:00
inherit (haskellPackages) happy alex; # hope these aren't required for the final 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 17:26:58 +01:00
ghc = ghc6101Binary; };
Added ghc-6.12.2. svn path=/nixpkgs/trunk/; revision=21303
2010-04-25 18:27:21 +01:00
});
*/
Added GHC HEAD snapshot. svn path=/nixpkgs/trunk/; revision=17227
2009-09-17 12:45:20 +01:00
HaXe: support nekotools boot - add haxelib svn path=/nixpkgs/trunk/; revision=20674
2010-03-16 23:34:56 +00:00
haxeDist = import ../development/compilers/haxe {
inherit fetchurl sourceFromHead stdenv lib ocaml zlib makeWrapper neko;
adding haxe svn path=/nixpkgs/trunk/; revision=18708
2009-11-30 01:05:04 +00:00
};
HaXe: support nekotools boot - add haxelib svn path=/nixpkgs/trunk/; revision=20674
2010-03-16 23:34:56 +00:00
haxe = haxeDist.haxe;
haxelib = haxeDist.haxelib;
adding haxe svn path=/nixpkgs/trunk/; revision=18708
2009-11-30 01:05:04 +00:00
Adding Falcon multiparadigm programming language. It has macros and non-trivial syntax at once, which seems interesting in itself.. svn path=/nixpkgs/trunk/; revision=16299
2009-07-09 23:30:19 +01: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 17:26:58 +01:00
go = callPackage ../development/compilers/go { };
* Add the Go Programming Language compiler. svn path=/nixpkgs/trunk/; revision=18348
2009-11-14 20:14:28 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gprolog = callPackage ../development/compilers/gprolog { };
Add GNU Prolog. svn path=/nixpkgs/trunk/; revision=14122
2009-02-19 13:32:07 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gwt = callPackage ../development/compilers/gwt {
Added google webtoolkit svn path=/nixpkgs/trunk/; revision=10653
2008-02-13 08:43:38 +00:00
inherit (gtkLibs) glib gtk pango atk;
libstdcpp5 = gcc33.gcc;
};
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ikarus = callPackage ../development/compilers/ikarus { };
all-packages.nix changes for previous commits svn path=/nixpkgs/trunk/; revision=11758
2008-05-06 08:03:41 +01:00
hugs98 svn path=/nixpkgs/trunk/; revision=9169
2007-08-20 11:34:49 +01: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 17:26:58 +01:00
hugs = callPackage ../development/compilers/hugs { };
hugs98 svn path=/nixpkgs/trunk/; revision=9169
2007-08-20 11:34:49 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
path64 = callPackage ../development/compilers/path64 {
Adding a skeleton for the path64 compiler. It builds, but it needs some reworks as running it lookes at /usr/bin/ld and things like that. I leave that for another day. svn path=/nixpkgs/trunk/; revision=22442
2010-07-02 22:44:31 +01:00
stdenv = stdenv2;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
openjdkDarwin = callPackage ../development/compilers/openjdk-darwin { };
added openjdk for darwin (binaries) for testing svn path=/nixpkgs/trunk/; revision=17596
2009-10-02 13:12:23 +01:00
Trying to reinstate the meta-based Hydra builds svn path=/nixpkgs/trunk/; revision=16883
2009-08-28 07:29:21 +01:00
j2sdk14x = (
* In the JDK packages, don't return false if the platform is unsupported. This gives a type error ("value is a boolean while an attribute set was expected"). svn path=/nixpkgs/trunk/; revision=8576
2007-04-16 11:07:06 +01:00
assert system == "i686-linux";
import ../development/compilers/jdk/default-1.4.nix {
inherit fetchurl stdenv;
Attempt to mark up packages with platform assertions svn path=/nixpkgs/trunk/; revision=16850
2009-08-25 07:36:05 +01:00
});
Update of jdk and jre to jdk-distros, based on Distributor License for Java. D pkgs/development/interpreters/jre Obsolete. jdk and jre are now build by the same expression. D pkgs/development/compilers/blackdown Obsolete. jdk is now downloadable. D pkgs/development/compilers/jdk/jdk5-sun-linux.nix Obsolete A pkgs/development/compilers/jdk/dlj-bundle-builder.sh Build for DLJ bundles. M pkgs/top-level/all-packages.nix Dropped blackdown and ant based on blackdown. A pkgs/development/compilers/jdk/jdk6-construct.sh Copy of DLJ construct script to fix problem with jdk6 bundles. A pkgs/development/compilers/jdk/jdk6-linux.nix New main Nix expression for jdk and jre. Supports mozillaPlugin. A pkgs/development/compilers/jdk/dlj-bundle-builder.sh Include path to libjli in rpath. svn path=/nixpkgs/trunk/; revision=8186
2007-03-05 17:13:53 +00:00
Trying to reinstate the meta-based Hydra builds svn path=/nixpkgs/trunk/; revision=16883
2009-08-28 07:29:21 +01:00
jdk5 = (
Added x86_64 version of JDK5 svn path=/nixpkgs/trunk/; revision=10272
2008-01-24 10:14:33 +00:00
assert system == "i686-linux" || system == "x86_64-linux";
Added JBoss svn path=/nixpkgs/trunk/; revision=10259
2008-01-23 12:25:08 +00:00
import ../development/compilers/jdk/default-5.nix {
inherit fetchurl stdenv unzip;
Attempt to mark up packages with platform assertions svn path=/nixpkgs/trunk/; revision=16850
2009-08-25 07:36:05 +01:00
});
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
nixpkgs: for darwin redirect jdk to openjdk svn path=/nixpkgs/trunk/; revision=20832
2010-03-26 13:31:11 +00:00
jdk = if stdenv.isDarwin then openjdkDarwin else jdkdistro true false;
jre: by default don't support the plugin svn path=/nixpkgs/trunk/; revision=8461
2007-03-28 19:55:57 +01:00
jre = jdkdistro false false;
Use jdk without plugin support svn path=/nixpkgs/trunk/; revision=8454
2007-03-28 16:31:00 +01:00
jdkPlugin = jdkdistro true true;
jre: by default don't support the plugin svn path=/nixpkgs/trunk/; revision=8461
2007-03-28 19:55:57 +01:00
jrePlugin = jdkdistro false true;
Make jdk plugin support optional to avoid deps on gcc 3.3.6 everywhere. svn path=/nixpkgs/trunk/; revision=8452
2007-03-28 16:21:43 +01:00
* Fix the JRE plugin test. svn path=/nixpkgs/trunk/; revision=8577
2007-04-16 11:22:20 +01:00
supportsJDK =
system == "i686-linux" ||
system == "x86_64-linux" ||
inital try with jdk6 on cygwin svn path=/nixpkgs/trunk/; revision=22000
2010-05-27 12:04:45 +01:00
system == "i686-cygwin" ||
* Fix the JRE plugin test. svn path=/nixpkgs/trunk/; revision=8577
2007-04-16 11:22:20 +01:00
system == "powerpc-linux";
* In the JDK packages, don't return false if the platform is unsupported. This gives a type error ("value is a boolean while an attribute set was expected"). svn path=/nixpkgs/trunk/; revision=8576
2007-04-16 11:07:06 +01:00
jdkdistro = installjdk: pluginSupport:
Trying to reinstate the meta-based Hydra builds svn path=/nixpkgs/trunk/; revision=16883
2009-08-28 07:29:21 +01:00
(assert supportsJDK;
* Fix Mesa-related evaluation errors. svn path=/nixpkgs/trunk/; revision=8708
2007-05-16 15:49:28 +01:00
(if pluginSupport then appendToName "plugin" else x: x) (import ../development/compilers/jdk {
inital try with jdk6 on cygwin svn path=/nixpkgs/trunk/; revision=22000
2010-05-27 12:04:45 +01:00
inherit fetchurl stdenv unzip installjdk xlibs pluginSupport makeWrapper cabextract;
Fix syntax error after the marking up svn path=/nixpkgs/trunk/; revision=16851
2009-08-25 07:40:26 +01:00
}));
* Added some missing semicolons. * Some packages needed for the Subversion server. svn path=/nixpkgs/trunk/; revision=586
2003-12-21 20:52:13 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jikes = callPackage ../development/compilers/jikes { };
Added j2sdk-1.5.0-beta svn path=/nixpkgs/trunk/; revision=1014
2004-05-12 16:06:23 +01:00
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
lazarus = builderDefsPackage (import ../development/compilers/fpc/lazarus.nix) {
Added Lazarus IDE for Free Pascal Compiler. svn path=/nixpkgs/trunk/; revision=11492
2008-04-08 16:11:34 +01:00
inherit fpc makeWrapper;
Use GTK2 for Lazarus and get Unicode support svn path=/nixpkgs/trunk/; revision=16363
2009-07-14 21:31:11 +01:00
inherit (gtkLibs) gtk glib pango atk;
Added Lazarus IDE for Free Pascal Compiler. svn path=/nixpkgs/trunk/; revision=11492
2008-04-08 16:11:34 +01:00
inherit (xlibs) libXi inputproto libX11 xproto libXext xextproto;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
llvm = callPackage ../development/compilers/llvm { };
LLVM compiler Low Level Virtual Machine http://www.llvm.org/ svn path=/nixpkgs/trunk/; revision=11156
2008-03-17 11:18:21 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mitscheme = callPackage ../development/compilers/mit-scheme { };
Add MIT/GNU Scheme. svn path=/nixpkgs/trunk/; revision=20719
2010-03-17 15:32:12 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mono = callPackage ../development/compilers/mono { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
monoDLLFixer = callPackage ../build-support/mono-dll-fixer { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mozart = callPackage ../development/compilers/mozart { };
Added ViewMTN and dependency; currently ViewMTN has to be manually symlinked in corresponding directory. svn path=/nixpkgs/trunk/; revision=12060
2008-06-12 16:59:59 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
neko = callPackage ../development/compilers/neko {
adding neko adding repository locations for haxe* and neko repositories svn path=/nixpkgs/trunk/; revision=18709
2009-11-30 01:05:07 +00:00
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 17:26:58 +01:00
nasm = callPackage ../development/compilers/nasm { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Make all ocaml versions available in the proper way. svn path=/nixpkgs/trunk/; revision=17805
2009-10-14 16:21:45 +01:00
ocaml = ocaml_3_11_1;
- O'Caml compiler for Object CaML - hevea is an interpreter for latex producing html svn path=/nixpkgs/trunk/; revision=1171
2004-07-16 23:58:15 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ocaml_3_08_0 = callPackage ../development/compilers/ocaml/3.08.0.nix { };
* Make all ocaml versions available in the proper way. svn path=/nixpkgs/trunk/; revision=17805
2009-10-14 16:21:45 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ocaml_3_10_0 = callPackage ../development/compilers/ocaml/3.10.0.nix { };
* Make all ocaml versions available in the proper way. svn path=/nixpkgs/trunk/; revision=17805
2009-10-14 16:21:45 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ocaml_3_11_1 = callPackage ../development/compilers/ocaml/3.11.1.nix { };
fixed ocaml/qcmm problem: -created separate nix expressions for ocaml-3.08.0 and ocaml 3.09.1 -ocam-3.09.1 is standard/default ocaml version (included by ocaml/default.nix) -created ocaml3080 in all-packages-generic.nix -qcmm now uses ocaml3080 instead of ocaml svn path=/nixpkgs/trunk/; revision=4935
2006-03-01 09:18:22 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
opencxx = callPackage ../development/compilers/opencxx {
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
gcc = gcc33;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
qcmm = callPackage ../development/compilers/qcmm {
fixed ocaml/qcmm problem: -created separate nix expressions for ocaml-3.08.0 and ocaml 3.09.1 -ocam-3.09.1 is standard/default ocaml version (included by ocaml/default.nix) -created ocaml3080 in all-packages-generic.nix -qcmm now uses ocaml3080 instead of ocaml svn path=/nixpkgs/trunk/; revision=4935
2006-03-01 09:18:22 +00:00
lua = lua4;
* Make all ocaml versions available in the proper way. svn path=/nixpkgs/trunk/; revision=17805
2009-10-14 16:21:45 +01:00
ocaml = ocaml_3_08_0;
added version to uuagc added: noweb, lua-5.x, lua-4.x, mk, qc-- (as qcmm) svn path=/nixpkgs/trunk/; revision=4681
2006-02-02 17:07:07 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
roadsend = callPackage ../development/compilers/roadsend { };
added roadsend PHP-Compiler svn path=/nixpkgs/trunk/; revision=10550
2008-02-08 01:57:31 +00:00
Updating CLisp and adding SBCL. SBCL currently has to be symlinked to a writable directory (I am investigating a fix). CLisp 2.47 is somewhat incompatible with lots of software, so I added 2.44.1 as preserved version svn path=/nixpkgs/trunk/; revision=15806
2009-05-31 07:07:25 +01:00
sbcl = builderDefsPackage (import ../development/compilers/sbcl) {
Try updating SBCL svn path=/nixpkgs/trunk/; revision=20066
2010-02-17 06:50:45 +00:00
inherit makeWrapper clisp;
Updating CLisp and adding SBCL. SBCL currently has to be symlinked to a writable directory (I am investigating a fix). CLisp 2.47 is somewhat incompatible with lots of software, so I added 2.44.1 as preserved version svn path=/nixpkgs/trunk/; revision=15806
2009-05-31 07:07:25 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
scala = callPackage ../development/compilers/scala { };
added scala an object oriented and functional programming language svn path=/nixpkgs/trunk/; revision=11593
2008-04-11 23:06:32 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
stalin = callPackage ../development/compilers/stalin { };
Add Stalin, an efficient Scheme compiler. svn path=/nixpkgs/trunk/; revision=11927
2008-05-29 13:10:10 +01:00
* More cleanup. Updated to the latest Stratego/XT 0.17. svn path=/nixpkgs/trunk/; revision=14610
2009-03-19 14:34:16 +00:00
strategoPackages = strategoPackages017;
* Added a tool `mono-dll-fixer' to absolutise the DLL maps in the `*.dll.config' files corresponding to CLR assemblies. I.e., the full path to native libraries is included in the maps. In effect this allows us to set the equivalent of an RPATH for assemblies. * gtk-sharp: use the DLL fixer. It's not perfect yet: I still have to set the LD_LIBRARY_PATH for monodoc to include the gtk-sharp lib directory itself, so that it can find the `*sharpglue.so' files. This seems to be gtk-sharp's fault; it doesn't have an entry for those libraries in its DLL maps. svn path=/nixpkgs/trunk/; revision=2330
2005-03-03 17:19:58 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
strategoPackages016 = callPackage ../development/compilers/strategoxt/0.16.nix {
* Make it easier to override parts of stdenv (like gcc or make) per package using the `overrideGCC' and `overrideInStdenv' functions. svn path=/nixpkgs/trunk/; revision=5505
2006-06-23 21:11:36 +01:00
stdenv = overrideInStdenv stdenv [gnumake380];
* Added unstable pre release of Stratego/XT 0.16 * Upgraded bibtex-tools to latest unstable release. svn path=/nixpkgs/trunk/; revision=4176
2005-10-31 14:28:11 +00:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
strategoPackages017 = callPackage ../development/compilers/strategoxt/0.17.nix {
stratego shell svn path=/nixpkgs/trunk/; revision=18677
2009-11-27 20:22:43 +00:00
readline = readline5;
strategoxt-utils svn path=/nixpkgs/trunk/; revision=3271
2005-06-30 17:54:25 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
strategoPackages018 = callPackage ../development/compilers/strategoxt/0.18.nix {
pkgs/development/compilers/swi-prolog/default.nix: updated to version 5.6.64 and enabled GUI support svn path=/nixpkgs/trunk/; revision=18853
2009-12-09 14:07:09 +00:00
readline = readline5;
added stratego 0.18 pre release svn path=/nixpkgs/trunk/; revision=17157
2009-09-15 12:36:41 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
metaBuildEnv = callPackage ../development/compilers/meta-environment/meta-build-env { };
meta-build-env svn path=/nixpkgs/trunk/; revision=14850
2009-04-03 10:22:20 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
swiProlog = callPackage ../development/compilers/swi-prolog { };
* Add swi-prolog without any options. svn path=/nixpkgs/trunk/; revision=11003
2008-03-06 21:53:54 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
tinycc = callPackage ../development/compilers/tinycc { };
Add TinyCC (TCC), a small, fast, and embeddable C compiler and interpreter. svn path=/nixpkgs/trunk/; revision=13168
2008-10-31 16:52:44 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
vala = callPackage ../development/compilers/vala { };
vala - Compiler for the GObject type system svn path=/nixpkgs/trunk/; revision=22546
2010-07-09 14:15:40 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
visualcpp = callPackage ../development/compilers/visual-c++ { };
* A wrapper around the Visual C++ compiler and the Windows SDK. TODO: download and unpack into the Nix store Visual C++ (either from Visual C++ Express Edition or from the .NET 2.0 Framework SDK) and the Windows Platform SDK. The command line tools don't seem to need any registry settings... svn path=/nixpkgs/trunk/; revision=5369
2006-06-02 10:56:10 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
vs90wrapper = callPackage ../development/compilers/vs90wrapper { };
Added my very experimental Visual Studio build stuff. You should be even more brave to use this svn path=/nixpkgs/trunk/; revision=22273
2010-06-15 12:32:19 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
webdsl = callPackage ../development/compilers/webdsl { };
Added WebDSL svn path=/nixpkgs/trunk/; revision=10375
2008-01-29 11:46:34 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
win32hello = callPackage ../development/compilers/visual-c++/test { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
Improved support for building 32-bit binaries on x86_64-linux. * glibc_multi: a wrapper that combines the 32-bit and 64-bit Glibcs. This is necessary so that 64-bit GCC can find gnu/stubs-32.h and the 32-bit Glibc libraries. To build glibc_multi on x86_64-linux, you still need either the i686-linux Glibc derivation from a channel, or to have configured Nix with support for forwarding the build to a i686-linux machine. In the future this may become unnecessary by providing a prebuilt binary of 32-bit Glibc somewhere (like the binaries used in the stdenvLinux bootstrap). * With glibc_multi, it becomes possible to build gcc with multilib support (i.e. it builds 32-bit and 64-bit versions of libgcc, libstdc++, etc.). svn path=/nixpkgs/trunk/; revision=12203
2008-06-27 19:26:19 +01:00
wrapGCCWith = gccWrapper: glibc: baseGCC: gccWrapper {
Getting a new gcc-wrapper on the way. After gnat-wrapper, I introduce ghdl-wrapper. I made the gcc-4.3.4 expression allow the 'vhdl' language through ghdl. The ghdl developer recommends this gcc version; maybe it would work with gcc-4.4. If not this ghdl version, maybe next versions. svn path=/nixpkgs/branches/stdenv-updates/; revision=19071
2009-12-21 23:02:06 +00: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;
inherit stdenv binutils coreutils zlib;
};
Merging the ghdl-wrapper and gcc-wrapper into one. I will remove the ghdl-wrapper files later, if all this works. svn path=/nixpkgs/branches/stdenv-updates/; revision=19493
2010-01-16 21:41:27 +00:00
wrapGCC = wrapGCCWith (import ../build-support/gcc-wrapper) glibc;
Trying to fix the nixpkgs-tarball, after I broke it again due to assuming 'gcc' to be pure as that of stdenvLinux. svn path=/nixpkgs/trunk/; revision=20671
2010-03-16 21:53:48 +00:00
Fixing once again the ld-wrapper.sh script. I put it in a gcc-wrapper apart, to be removed on the next stdenv-updates. This would fix the build for many cmake packages, although that requires updating the stdenv in those for its gcc to use this 2nd wrapper. I updated paraview and avidemux. I can't recall now more packages with problems, but I was quite sure there were. If anyone sees a cmake-built package with the result binaries lacking some rpaths, then try this wrapper. svn path=/nixpkgs/trunk/; revision=20669
2010-03-16 20:49:26 +00:00
# To be removed on stdenv-updates
# By now this has at least the fix of setting the proper rpath when a file "libbla.so"
# is passed directly to the linker.
# This is of interest to programs built by cmake, because this is a common practice
# in cmake builds.
wrapGCC2 = wrapGCCWith (import ../build-support/gcc-wrapper/default2.nix) glibc;
Trying to fix the nixpkgs-tarball, after I broke it again due to assuming 'gcc' to be pure as that of stdenvLinux. svn path=/nixpkgs/trunk/; revision=20671
2010-03-16 21:53:48 +00:00
stdenv2 = if (gcc.nativeTools) then stdenv else (overrideGCC stdenv (wrapGCC2 gcc.gcc));
Getting a new gcc-wrapper on the way. After gnat-wrapper, I introduce ghdl-wrapper. I made the gcc-4.3.4 expression allow the 'vhdl' language through ghdl. The ghdl developer recommends this gcc version; maybe it would work with gcc-4.4. If not this ghdl version, maybe next versions. svn path=/nixpkgs/branches/stdenv-updates/; revision=19071
2009-12-21 23:02:06 +00:00
Fixing many things related to the cross compilation in stdenvCross. It still does not work, but I think I already get glibc cross compiled. Next: gcc and g++, and set some setup script hooks on stdenvCross. It took quite enough hours for this commit. svn path=/nixpkgs/branches/stdenv-updates/; revision=18351
2009-11-15 05:28:35 +00:00
wrapGCCCross =
{gcc, libc, binutils, cross, shell ? "", name ? "gcc-cross-wrapper"}:
pkgs/top-level/all-packages.nix: switch to Python 2.6 (except on Darwin) MacOS X can build Python 2.6 just fine, but for some reason a lot of modules don't work, so the resulting binary isn't very useful. svn path=/nixpkgs/branches/stdenv-updates/; revision=19598
2010-01-21 15:39:11 +00: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 19:51:45 +00:00
forceBuildDrv (import ../build-support/gcc-cross-wrapper {
Fixing many things related to the cross compilation in stdenvCross. It still does not work, but I think I already get glibc cross compiled. Next: gcc and g++, and set some setup script hooks on stdenvCross. It took quite enough hours for this commit. svn path=/nixpkgs/branches/stdenv-updates/; revision=18351
2009-11-15 05:28:35 +00:00
nativeTools = false;
nativeLibc = false;
Fixed some details on cross compilation. Among others: - Stating better the guile dependencies (native/host) for guile to build - Fixing cross-linking, through --rpath-link (ld(1) explains well about it - Made gcc call the linker and the assembler through the gcc wrapper instead of directly. I thought this was the source of missing -rpath's, but the source of the problem ended up being the lack of --rpath-link. But I think the native gcc calls the wrapped ld and as, so let's do the same cross compiling. - Removed the binutilsCross from the glibc expressions. Now they are built using the gcc-cross-wrapper, and they were built with the direct gcc and binutils before this change. - I think patchelf and strip don't break the cross-compiled binaries, so I reallow them on cross compilation. - I disable the checkPhase on cross compilation. This made gmp and libtool fail when cross compiled, iirc. svn path=/nixpkgs/branches/stdenv-updates/; revision=18498
2009-11-21 02:42:52 +00: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 19:03:34 +00: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 19:51:45 +00:00
});
Fixing many things related to the cross compilation in stdenvCross. It still does not work, but I think I already get glibc cross compiled. Next: gcc and g++, and set some setup script hooks on stdenvCross. It took quite enough hours for this commit. svn path=/nixpkgs/branches/stdenv-updates/; revision=18351
2009-11-15 05:28:35 +00:00
Add GCC-UPC, a compiler for the UPC distributed shared memory language. svn path=/nixpkgs/trunk/; revision=10956
2008-03-04 16:20:11 +00: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;
* wrapGCC: pass the right purity options for the platform. svn path=/nixpkgs/trunk/; revision=8710
2007-05-16 16:15:46 +01:00
nativeLibc = stdenv ? gcc && stdenv.gcc.nativeLibc;
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
gcc = baseGCC;
* Switching. svn path=/nixpkgs/trunk/; revision=6827
2006-10-24 21:53:54 +01:00
libc = glibc;
inherit stdenv binutils;
* A Hello World GUI application compiled with VC++. svn path=/nixpkgs/trunk/; revision=5370
2006-06-02 11:09:19 +01:00
};
yap prolog system added svn path=/nixpkgs/trunk/; revision=11090
2008-03-13 01:13:53 +00: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 17:26:58 +01:00
yap = callPackage ../development/compilers/yap { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
yasm = callPackage ../development/compilers/yasm { };
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
### DEVELOPMENT / INTERPRETERS
Adding ACL2. ACL2 = A Computational Logic for Applicative Common Lisp. It is a Lisp sublanguage and a correctness prover for it. svn path=/nixpkgs/trunk/; revision=16708
2009-08-13 15:32:52 +01:00
acl2 = builderDefsPackage ../development/interpreters/acl2 {
inherit sbcl;
};
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
clisp = callPackage ../development/interpreters/clisp { };
Updating CLisp and adding SBCL. SBCL currently has to be symlinked to a writable directory (I am investigating a fix). CLisp 2.47 is somewhat incompatible with lots of software, so I added 2.44.1 as preserved version svn path=/nixpkgs/trunk/; revision=15806
2009-05-31 07:07:25 +01:00
# compatibility issues in 2.47 - at list 2.44.1 is known good
# for sbcl bootstrap
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
clisp_2_44_1 = callPackage ../development/interpreters/clisp/2.44.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 17:26:58 +01:00
libsigsegv = libsigsegv_25; };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
erlang = callPackage ../development/interpreters/erlang { };
Added erlang/ejabberd packages svn path=/nixpkgs/trunk/; revision=10258
2008-01-23 10:06:07 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
erlangR13B = callPackage ../development/interpreters/erlang/R13B.nix { };
Ejabberd will use old Erlang for now svn path=/nixpkgs/trunk/; revision=22477
2010-07-05 13:47:35 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
groovy = callPackage ../development/interpreters/groovy { };
add Groovy 1.7.1 patch provided by Francois Perrad svn path=/nixpkgs/trunk/; revision=20862
2010-03-30 00:36:32 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
guile = callPackage ../development/interpreters/guile { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
guile_1_9 = callPackage ../development/interpreters/guile/1.9.nix { };
GNU Guile 1.9.3. svn path=/nixpkgs/trunk/; revision=17188
2009-09-16 13:46:17 +01:00
Added Io programming language svn path=/nixpkgs/trunk/; revision=13241
2008-11-11 08:53:47 +00:00
io = builderDefsPackage (import ../development/interpreters/io) {
inherit sqlite zlib gmp libffi cairo ncurses freetype mesa
libpng libtiff libjpeg readline libsndfile libxml2
* editline: renamed to libedit (which seems to be the proper name for the package). * Removed the old ghc-wrapper, which hasn't been used for a long time. * Renamed the "boot" GHC to "binary", which is more descriptive. (They *can* be used for other things than bootstrapping a GHC source build.) * Updated the GHC 6.10.1 binary to 6.10.2. svn path=/nixpkgs/trunk/; revision=15095
2009-04-16 20:25:22 +01:00
freeglut e2fsprogs libsamplerate pcre libevent libedit;
Added Io programming language svn path=/nixpkgs/trunk/; revision=13241
2008-11-11 08:53:47 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
kaffe = callPackage ../development/interpreters/kaffe { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lua4 = callPackage ../development/interpreters/lua-4 { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lua5 = callPackage ../development/interpreters/lua-5 { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
maude = callPackage ../development/interpreters/maude { };
maude, tecla, buddy: new packages Maude is a high-level specification language. Buddy and libtecla are required to build Maude. svn path=/nixpkgs/trunk/; revision=12358
2008-07-15 10:58:30 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
octave = callPackage ../development/interpreters/octave {
Adding graphicsmagick 1.3.7 for octave imread() and alike to work. svn path=/nixpkgs/trunk/; revision=20390
2010-03-04 16:41:14 +00:00
# Needed because later gm versions require an initialization the actual octave is not
# doing.
# http://www-old.cae.wisc.edu/pipermail/octave-maintainers/2010-February/015295.html
graphicsmagick = graphicsmagick137;
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
};
bleeding edge octave version (without docs) svn path=/nixpkgs/trunk/; revision=13561
2008-12-02 22:55:45 +00: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 17:26:58 +01:00
octaveHG = callPackage ../development/interpreters/octave/hg.nix { };
bleeding edge octave version (without docs) svn path=/nixpkgs/trunk/; revision=13561
2008-12-02 22:55:45 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
perl58 = callPackage ../development/interpreters/perl-5.8 {
* Fix Perl on FreeBSD. svn path=/nixpkgs/branches/stdenv-updates/; revision=19685
2010-01-26 18:10:59 +00:00
impureLibcPath = if stdenv.isLinux then null else "/usr";
};
* Revert r10833, it doesn't really work. Instead build ghcboot with Perl 5.8. svn path=/nixpkgs/branches/stdenv-updates-merge/; revision=10834
2008-02-22 14:43:00 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
perl510 = callPackage ../development/interpreters/perl-5.10 {
perl-5.8 and perl-5.10: fixed build on MacOS X On MacOS X, we used to use the native perl interpreter from /usr/bin. Unfortunately, that interpreter fails to build a number of packages (Subversion, Git, etc. ...), because it assumes knowledge about the underlying C compiler that is not valid for the compiler used by Nix. For example, /usr/bin/perl assumes that the compiler can build binaries for both the ppc and the x86 architecture. /usr/bin/gcc can do that, but the gcc from Nix can't. The solution is to compile Perl 5.10 in Nix so that the ./configure phase can properly detect the system's capabilities. However, note that the resulting binary is impure: it will find headers in /usr/include and libraries in /usr/lib. In this respect, the Nix-compiled perl binary is no different than the native one in /usr/bin -- it's just configured more accurately. svn path=/nixpkgs/trunk/; revision=17870
2009-10-19 10:17:10 +01:00
fetchurl = fetchurlBoot;
Reverting simons' r17618, which causes a major stdenv rebuild. svn path=/nixpkgs/trunk/; revision=17622
2009-10-02 20:05:39 +01:00
};
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
perl = if system != "i686-cygwin" then perl510 else sysPerl;
* "Fix" Perl on Cygwin. svn path=/nixpkgs/trunk/; revision=18129
2009-11-05 09:11:25 +00:00
* Finish renaming. svn path=/nixpkgs/trunk/; revision=22801
2010-07-29 08:02:26 +01:00
php = makeOverridable (import ../development/interpreters/php) {
* Cleaned up the PHP expression. Added support for GD. Also turned on PostgreSQL support by default (maybe I shouldn't, since it makes PHP rather dependency-heavy...). svn path=/nixpkgs/trunk/; revision=12002
2008-06-06 14:03:55 +01:00
inherit
removed mkDerivationByConfiguration, using composableDerivation instead qgis, vim_configurable both work now svn path=/nixpkgs/trunk/; revision=13661
2008-12-20 01:20:35 +00:00
stdenv fetchurl lib composableDerivation autoconf automake
* Finish renaming. svn path=/nixpkgs/trunk/; revision=22801
2010-07-29 08:02:26 +01:00
flex bison apacheHttpd mysql libxml2
adding PHP. 5.3.2. See comments. I had to add the newer PHP because current PHP 5.2.11 doesn't read SOAP from https urls. Debian's PHP does work - I couldn't find their fix svn path=/nixpkgs/trunk/; revision=22056
2010-05-29 19:26:54 +01:00
zlib curl gd postgresql openssl pkgconfig sqlite getConfig libiconv libjpeg libpng;
broken comment php_unstable when compiling wihtout xdebug/ xdebug supported svn path=/nixpkgs/trunk/; revision=10056
2008-01-03 10:46:18 +00:00
};
PHP with some configuration flags serving as example. Perhaps you can to extend it more easily if you need to svn path=/nixpkgs/trunk/; revision=9588
2007-11-05 21:13:16 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
phpXdebug = callPackage ../development/interpreters/php-xdebug { };
moving xdebug into its own package. This means you have to specify an additional php.ini file to make php debugger work for command line php. svn path=/nixpkgs/trunk/; revision=19266
2010-01-06 17:04:38 +00:00
Added PLT Scheme svn path=/nixpkgs/trunk/; revision=12370
2008-07-17 10:57:47 +01:00
pltScheme = builderDefsPackage (import ../development/interpreters/plt-scheme) {
added maude beta version svn path=/nixpkgs/trunk/; revision=12384
2008-07-18 21:11:02 +01:00
inherit cairo fontconfig freetype libjpeg libpng openssl
Added PLT Scheme svn path=/nixpkgs/trunk/; revision=12370
2008-07-17 10:57:47 +01:00
perl mesa zlib which;
added maude beta version svn path=/nixpkgs/trunk/; revision=12384
2008-07-18 21:11:02 +01:00
inherit (xorg) libX11 libXaw libXft libXrender libICE xproto
renderproto pixman libSM libxcb libXext xextproto libXmu
Added PLT Scheme svn path=/nixpkgs/trunk/; revision=12370
2008-07-17 10:57:47 +01:00
libXt;
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
Added PLT Scheme svn path=/nixpkgs/trunk/; revision=12370
2008-07-17 10:57:47 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
polyml = callPackage ../development/compilers/polyml { };
Add expression for PolyML svn path=/nixpkgs/trunk/; revision=18875
2009-12-10 13:16:06 +00:00
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
python = if getConfig ["python" "full"] false then pythonFull else pythonBase;
python25 = if getConfig ["python" "full"] false then python25Full else python25Base;
python26 = if getConfig ["python" "full"] false then python26Full else python26Base;
Added Python version 2.7. svn path=/nixpkgs/trunk/; revision=23117
2010-08-11 16:49:03 +01:00
python27 = if getConfig ["python" "full"] false then python27Full else python27Base;
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
pythonBase = python26Base;
pythonFull = python26Full;
Added "python-$version-wrapper" expression. The python wrapper expression expects a list of Python modules, $extraLibs, which are added to $PYTHONPATH before executing the actual Python interpreter. svn path=/nixpkgs/trunk/; revision=23194
2010-08-16 18:03:35 +01:00
pythonWrapper = callPackage ../development/interpreters/python/wrapper.nix { };
pkgs/top-level/all-packages.nix: lower priority of the various python versions to give preference to pythonWrapper svn path=/nixpkgs/trunk/; revision=23202
2010-08-17 11:19:48 +01:00
python24 = lowPrio (callPackage ../development/interpreters/python/2.4 { });
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
pkgs/top-level/all-packages.nix: lower priority of the various python versions to give preference to pythonWrapper svn path=/nixpkgs/trunk/; revision=23202
2010-08-17 11:19:48 +01:00
python25Base = lowPrio (makeOverridable (import ../development/interpreters/python/2.5) {
Python 2.5: Add GDBM support. svn path=/nixpkgs/trunk/; revision=11485
2008-04-08 08:37:49 +01:00
inherit fetchurl stdenv zlib bzip2 gdbm;
pkgs/top-level/all-packages.nix: lower priority of the various python versions to give preference to pythonWrapper svn path=/nixpkgs/trunk/; revision=23202
2010-08-17 11:19:48 +01:00
});
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
python: support ncurses, replace composedArgsAndFun by makeOverridable because composedArgsAndFun didn't pass values to the builder svn path=/nixpkgs/trunk/; revision=21686
2010-05-09 15:33:50 +01:00
python25Full = lowPrio (python25Base.override {
gpsd: Fix client programs. svn path=/nixpkgs/trunk/; revision=15812
2009-06-01 01:03:08 +01:00
# FIXME: We lack ncurses support, needed, e.g., for `gpsd'.
Defaukt for python-full is everything-on svn path=/nixpkgs/trunk/; revision=13104
2008-10-22 23:08:56 +01:00
db4 = if getConfig ["python" "db4Support"] true then db4 else null;
sqlite = if getConfig ["python" "sqliteSupport"] true then sqlite else null;
readline = if getConfig ["python" "readlineSupport"] true then readline else null;
openssl = if getConfig ["python" "opensslSupport"] true then openssl else null;
Added Tk support for Python svn path=/nixpkgs/trunk/; revision=13526
2008-12-01 00:02:25 +00:00
tk = if getConfig ["python" "tkSupport"] true then tk else null;
tcl = if getConfig ["python" "tkSupport"] true then tcl else null;
libX11 = if getConfig ["python" "tkSupport"] true then xlibs.libX11 else null;
xproto = if getConfig ["python" "tkSupport"] true then xlibs.xproto else null;
python: support ncurses, replace composedArgsAndFun by makeOverridable because composedArgsAndFun didn't pass values to the builder svn path=/nixpkgs/trunk/; revision=21686
2010-05-09 15:33:50 +01:00
ncurses = if getConfig ["python" "curses"] true then ncurses else null;
* Give Python 3.1 a lower priority so that it isn't installed by default when you do "nix-env -i python" and to allow it to be installed in the same profile as Python 2.x. * Disambiguate between the variants of Python 2.x. svn path=/nixpkgs/trunk/; revision=21237
2010-04-22 14:09:02 +01:00
});
* Adde xpra. Doesn't quite work yet. * Removed python_alts. svn path=/nixpkgs/trunk/; revision=11161
2008-03-17 13:45:50 +00:00
pkgs/top-level/all-packages.nix: lower priority of the various python versions to give preference to pythonWrapper svn path=/nixpkgs/trunk/; revision=23202
2010-08-17 11:19:48 +01:00
python26Base = lowPrio (makeOverridable (import ../development/interpreters/python/2.6) {
python 2.6.3: initial version of python 2.6 support The build succeeds on i686-linux. Other platforms look good, too, because there were hardly any changes necessary to update the expression from 2.5. svn path=/nixpkgs/trunk/; revision=17889
2009-10-20 00:10:09 +01:00
inherit fetchurl stdenv zlib bzip2 gdbm;
python-2.6: fixed build on Darwin * Dropped "nolongdouble.patch". The patch no longer applies to Python 2.6, and apparently isn't required anymore either. * Added access to native Darwin arch utility. Python tries to run 'arch' in the configure stage, but that binary reside in /usr/bin. To make it available to the expression, the small wrapper darwinArchUtility is added as a buildInput if appropriate. * Don't pass --enable-shared. The build fails if we try to enable building of shared libraries, apparently because some required libraries aren't linked, i.e. the linker call isn't right. TODO: * Figure out how to enable shared linking. * The resulting binary on Darwin seem to lack the binascii module. svn path=/nixpkgs/trunk/; revision=17894
2009-10-20 13:13:49 +01:00
arch = if stdenv.isDarwin then darwinArchUtility else null;
pkgs/development/interpreters/python/2.6/default.nix: fixed build on Darwin svn path=/nixpkgs/trunk/; revision=18136
2009-11-05 13:44:30 +00:00
sw_vers = if stdenv.isDarwin then darwinSwVersUtility else null;
pkgs/top-level/all-packages.nix: lower priority of the various python versions to give preference to pythonWrapper svn path=/nixpkgs/trunk/; revision=23202
2010-08-17 11:19:48 +01:00
});
python 2.6.3: initial version of python 2.6 support The build succeeds on i686-linux. Other platforms look good, too, because there were hardly any changes necessary to update the expression from 2.5. svn path=/nixpkgs/trunk/; revision=17889
2009-10-20 00:10:09 +01:00
python: support ncurses, replace composedArgsAndFun by makeOverridable because composedArgsAndFun didn't pass values to the builder svn path=/nixpkgs/trunk/; revision=21686
2010-05-09 15:33:50 +01:00
python26Full = lowPrio (python26Base.override {
python 2.6.3: initial version of python 2.6 support The build succeeds on i686-linux. Other platforms look good, too, because there were hardly any changes necessary to update the expression from 2.5. svn path=/nixpkgs/trunk/; revision=17889
2009-10-20 00:10:09 +01:00
# FIXME: We lack ncurses support, needed, e.g., for `gpsd'.
db4 = if getConfig ["python" "db4Support"] true then db4 else null;
sqlite = if getConfig ["python" "sqliteSupport"] true then sqlite else null;
readline = if getConfig ["python" "readlineSupport"] true then readline else null;
openssl = if getConfig ["python" "opensslSupport"] true then openssl else null;
tk = if getConfig ["python" "tkSupport"] true then tk else null;
tcl = if getConfig ["python" "tkSupport"] true then tcl else null;
libX11 = if getConfig ["python" "tkSupport"] true then xlibs.libX11 else null;
xproto = if getConfig ["python" "tkSupport"] true then xlibs.xproto else null;
python: support ncurses, replace composedArgsAndFun by makeOverridable because composedArgsAndFun didn't pass values to the builder svn path=/nixpkgs/trunk/; revision=21686
2010-05-09 15:33:50 +01:00
ncurses = if getConfig ["python" "curses"] true then ncurses else null;
* Give Python 3.1 a lower priority so that it isn't installed by default when you do "nix-env -i python" and to allow it to be installed in the same profile as Python 2.x. * Disambiguate between the variants of Python 2.x. svn path=/nixpkgs/trunk/; revision=21237
2010-04-22 14:09:02 +01:00
});
python 2.6.3: initial version of python 2.6 support The build succeeds on i686-linux. Other platforms look good, too, because there were hardly any changes necessary to update the expression from 2.5. svn path=/nixpkgs/trunk/; revision=17889
2009-10-20 00:10:09 +01:00
pkgs/top-level/all-packages.nix: lower priority of python27Base to ensure the full version is installed by default svn path=/nixpkgs/trunk/; revision=23146
2010-08-12 13:53:51 +01:00
python27Base = lowPrio (makeOverridable (import ../development/interpreters/python/2.7) {
Added Python version 2.7. svn path=/nixpkgs/trunk/; revision=23117
2010-08-11 16:49:03 +01:00
inherit fetchurl stdenv zlib bzip2 gdbm;
arch = if stdenv.isDarwin then darwinArchUtility else null;
sw_vers = if stdenv.isDarwin then darwinSwVersUtility else null;
pkgs/top-level/all-packages.nix: lower priority of python27Base to ensure the full version is installed by default svn path=/nixpkgs/trunk/; revision=23146
2010-08-12 13:53:51 +01:00
});
Added Python version 2.7. svn path=/nixpkgs/trunk/; revision=23117
2010-08-11 16:49:03 +01:00
pkgs/top-level/all-packages.nix: lower priority of the various python versions to give preference to pythonWrapper svn path=/nixpkgs/trunk/; revision=23202
2010-08-17 11:19:48 +01:00
python27Full = lowPrio (python27Base.override {
pkgs/top-level/all-packages.nix: dropped getConfig support for Python 2.7 Python 2.7 can no longer be configured using the obsolete "getConfig" mechanism. Instead, use "override" to fine-tune the installation. svn path=/nixpkgs/trunk/; revision=23143
2010-08-12 13:53:26 +01:00
inherit db4 sqlite readline openssl tcl tk ncurses;
inherit (xlibs) libX11 xproto;
pkgs/top-level/all-packages.nix: lower priority of the various python versions to give preference to pythonWrapper svn path=/nixpkgs/trunk/; revision=23202
2010-08-17 11:19:48 +01:00
});
Added Python version 2.7. svn path=/nixpkgs/trunk/; revision=23117
2010-08-11 16:49:03 +01:00
python: support ncurses, replace composedArgsAndFun by makeOverridable because composedArgsAndFun didn't pass values to the builder svn path=/nixpkgs/trunk/; revision=21686
2010-05-09 15:33:50 +01:00
python31Base = lowPrio (makeOverridable (import ../development/interpreters/python/3.1) {
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
inherit fetchurl stdenv zlib bzip2 gdbm;
arch = if stdenv.isDarwin then darwinArchUtility else null;
sw_vers = if stdenv.isDarwin then darwinSwVersUtility else null;
* Give Python 3.1 a lower priority so that it isn't installed by default when you do "nix-env -i python" and to allow it to be installed in the same profile as Python 2.x. * Disambiguate between the variants of Python 2.x. svn path=/nixpkgs/trunk/; revision=21237
2010-04-22 14:09:02 +01:00
});
pkgs/top-level/all-packages.nix: strip trailing white space svn path=/nixpkgs/trunk/; revision=21416
2010-04-29 09:54:02 +01:00
* Adde xpra. Doesn't quite work yet. * Removed python_alts. svn path=/nixpkgs/trunk/; revision=11161
2008-03-17 13:45:50 +00: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 17:26:58 +01:00
pyrex095 = callPackage ../development/interpreters/pyrex/0.9.5.nix { };
Added Compiz Fusion (main plugins). Also some dependencies, and made wmii build under setup-new-2.sh also. svn path=/nixpkgs/trunk/; revision=9577
2007-11-05 08:32:20 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pyrex096 = callPackage ../development/interpreters/pyrex/0.9.6.nix { };
Fixed log nesting; added Qi. svn path=/nixpkgs/trunk/; revision=9601
2007-11-08 14:34:54 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
qi = callPackage ../development/compilers/qi { };
Fixed log nesting; added Qi. svn path=/nixpkgs/trunk/; revision=9601
2007-11-08 14:34:54 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ruby18 = callPackage ../development/interpreters/ruby { };
* Remove some incorrect uses of makeOverridable. svn path=/nixpkgs/trunk/; revision=18483
2009-11-20 12:51:14 +00:00
#ruby19 = import ../development/interpreters/ruby/ruby-19.nix { inherit ruby18 fetchurl; };
ruby / gems update svn path=/nixpkgs/trunk/; revision=16099
2009-06-30 15:29:17 +01:00
ruby = ruby18;
all-packages.nix changes for all the previous commits svn path=/nixpkgs/trunk/; revision=11564
2008-04-11 10:32:27 +01:00
adding rubygems support to nix - implemented target libraries/apps: sup mail client svn path=/nixpkgs/trunk/; revision=16100
2009-06-30 15:29:20 +01:00
rubyLibs = recurseIntoAttrs (import ../development/interpreters/ruby/libs.nix {
inherit pkgs stdenv;
});
all-packages.nix changes for all the previous commits svn path=/nixpkgs/trunk/; revision=11564
2008-04-11 10:32:27 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
rake = callPackage ../development/ruby-modules/rake { };
Add all my latest packages to all-packages.nix svn path=/nixpkgs/trunk/; revision=12957
2008-10-05 10:04:30 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
rubySqlite3 = callPackage ../development/ruby-modules/sqlite3 { };
Add all my latest packages to all-packages.nix svn path=/nixpkgs/trunk/; revision=12957
2008-10-05 10:04:30 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
rLang = callPackage ../development/interpreters/r-lang {
- Some Ruby interpreter bumped version - Kernel headers 2.6.18 added (XEN virtual images) - unifdef package added for kernel headers 2.6.18 - Python Zope and 4suite added - Trying bioconductor packages with R-lang (still failing) - Bumped gmp version - Added rq cluster runner - still requires extra gems (installs, but does not run) svn path=/nixpkgs/trunk/; revision=12766
2008-08-29 14:53:28 +01:00
withBioconductor = getConfig ["rLang" "withBioconductor"] false;
Support for R-language (statistical) svn path=/nixpkgs/trunk/; revision=11769
2008-05-07 12:24:28 +01:00
};
doh - fix rubygems svn path=/nixpkgs/trunk/; revision=16109
2009-06-30 17:14:37 +01:00
rubygemsFun = ruby: builderDefsPackage (import ../development/interpreters/ruby/gems.nix) {
all-packages.nix changes for all the previous commits svn path=/nixpkgs/trunk/; revision=11564
2008-04-11 10:32:27 +01:00
inherit ruby makeWrapper;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
doh - fix rubygems svn path=/nixpkgs/trunk/; revision=16109
2009-06-30 17:14:37 +01:00
rubygems = rubygemsFun ruby;
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
rq = callPackage ../applications/networking/cluster/rq { };
- Some Ruby interpreter bumped version - Kernel headers 2.6.18 added (XEN virtual images) - unifdef package added for kernel headers 2.6.18 - Python Zope and 4suite added - Trying bioconductor packages with R-lang (still failing) - Bumped gmp version - Added rq cluster runner - still requires extra gems (installs, but does not run) svn path=/nixpkgs/trunk/; revision=12766
2008-08-29 14:53:28 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
scsh = callPackage ../development/interpreters/scsh { };
Add packages scsh, The Scheme Shell svn path=/nixpkgs/trunk/; revision=18248
2009-11-07 11:17:53 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
spidermonkey = callPackage ../development/interpreters/spidermonkey { };
Add an RC (1.8.0-rc1) of SpiderMonkey by cloning the release expression svn path=/nixpkgs/trunk/; revision=23030
2010-08-07 22:44:13 +01:00
spidermonkey_1_8_0rc1 = callPackage ../development/interpreters/spidermonkey/1.8.0-rc1.nix { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
sysPerl = callPackage ../development/interpreters/sys-perl { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
tcl = callPackage ../development/interpreters/tcl { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
xulrunnerWrapper = {application, launcher}:
import ../development/interpreters/xulrunner/wrapper {
* xulrunner-wrapper: use Firefox 3 directly (via "firefox -app"), since it has full support for running XUL applications. This saves a lot of space (you don't need two copies of basically the same software). * Deleted the old xulrunner (1.8.0.4), it didn't compile anyway with recent GTK. * Updated chatzilla to 0.9.83. svn path=/nixpkgs/trunk/; revision=12794
2008-09-04 10:29:09 +01:00
inherit stdenv application launcher;
* Fix evaluation problems. svn path=/nixpkgs/branches/x-updates/; revision=22668
2010-07-19 23:24:26 +01:00
xulrunner = firefox36Pkgs.xulrunner;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
### DEVELOPMENT / MISC
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
avrgcclibc = callPackage ../development/misc/avr-gcc-with-avr-libc {
fix avrlibcgcc svn path=/nixpkgs/trunk/; revision=17015
2009-09-10 17:57:06 +01:00
gcc = gcc40;
added avr gcc avrlibc dev environment. Its not worth doing this properly. It works this way svn path=/nixpkgs/trunk/; revision=14095
2009-02-17 12:56:35 +00:00
};
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
avr8burnomat = callPackage ../development/misc/avr8-burn-omat { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
/*
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
toolbus = callPackage ../development/interpreters/toolbus { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
*/
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
removing old bleeding edge cruft replacing it by a niftier version using source regions which are substituded by the tool nix-repository-manager. See http://github.com/MarcWeber/nix-repository-manager/raw/master/README. sourceByName is called sourceFromHead now. updates: MPlayerTrunk, haxe, neko, netsurf, cinelerra, ctags cinelerra does no longer build due to Xorg update svn path=/nixpkgs/trunk/; revision=18894
2009-12-11 13:58:23 +00:00
sourceFromHead = import ../build-support/source-from-head-fun.nix {
inherit getConfig;
jdk updated to 1.5.0.15 updated bleeding edge stuff (should now work for the bulidfarm as well because dist files are stored on my server) moved experimental my_env into its own file svn path=/nixpkgs/trunk/; revision=11026
2008-03-09 00:08:45 +00:00
};
- fetchdarcs supports now partial - fetchdarcs_2pre added - flapjax added - no longer used : annotatedDerivations - added bleeding edge repos with a tiny nix repository manager which dowloads and updates repostiries, then creates tar.gz dist files which are used by bleeding_edge_source (darcs tested only by now) - added experimental my_environment with example svn path=/nixpkgs/trunk/; revision=10974
2008-03-06 02:46:29 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ecj = callPackage ../development/eclipse/ecj { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
ecj for darwin svn path=/nixpkgs/trunk/; revision=20311
2010-03-01 16:20:47 +00: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 17:26:58 +01:00
jdtsdk = callPackage ../development/eclipse/jdt-sdk { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jruby116 = callPackage ../development/interpreters/jruby { };
adding jruby-1.1.6 cause the one shipping with netbeans can't get uid. svn path=/nixpkgs/trunk/; revision=16060
2009-06-26 17:52:58 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
guileCairo = callPackage ../development/guile-modules/guile-cairo { };
Add Guile-Cairo. svn path=/nixpkgs/trunk/; revision=17653
2009-10-05 23:21:24 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
guileGnome = callPackage ../development/guile-modules/guile-gnome {
Add GNU guile-gnome. svn path=/nixpkgs/trunk/; revision=17657
2009-10-05 23:21:50 +01:00
gconf = gnome.GConf;
inherit (gnome) glib gnomevfs gtk libglade libgnome libgnomecanvas
libgnomeui 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 17:26:58 +01:00
guileLib = callPackage ../development/guile-modules/guile-lib { };
Add Guile-Lib, a collection of useful GNU Guile modules. svn path=/nixpkgs/trunk/; revision=10639
2008-02-12 11:16:53 +00:00
Trying to reinstate the meta-based Hydra builds svn path=/nixpkgs/trunk/; revision=16883
2009-08-28 07:29:21 +01:00
windowssdk = (
Attempt to mark up packages with platform assertions svn path=/nixpkgs/trunk/; revision=16850
2009-08-25 07:36:05 +01:00
import ../development/misc/windows-sdk {
inherit fetchurl stdenv cabextract;
});
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
### DEVELOPMENT / TOOLS
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
antlr = callPackage ../development/tools/parsing/antlr/2.7.7.nix { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
antlr3 = callPackage ../development/tools/parsing/antlr { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
antDarwin based on openjdk svn path=/nixpkgs/trunk/; revision=17597
2009-10-02 13:27:24 +01:00
antDarwin = apacheAnt.override rec { jdk = openjdkDarwin ; name = "ant-" + jdk.name ; } ;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
ant = apacheAnt;
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
apacheAnt = callPackage ../development/tools/build-managers/apache-ant {
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
name = "ant-" + jdk.name; };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
apacheAnt14 = callPackage ../development/tools/build-managers/apache-ant {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
jdk = j2sdk14x;
name = "ant-" + j2sdk14x.name;
};
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
apacheAntGcj = callPackage ../development/tools/build-managers/apache-ant/from-source.nix { # must be either pre-built or built with GCJ *alone*
Ant/GCJ: Clean up. svn path=/nixpkgs/trunk/; revision=21990
2010-05-26 15:53:13 +01:00
gcj = gcj.gcc; # use the raw GCJ, which has ${gcj}/lib/jvm
Add Apache Ant, built from source with GCJ. svn path=/nixpkgs/trunk/; revision=17401
2009-09-24 15:49:15 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
autobuild = callPackage ../development/tools/misc/autobuild { };
Add Simon Josefsson's Autobuild tool. svn path=/nixpkgs/trunk/; revision=12442
2008-07-28 22:29:17 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
autoconf = callPackage ../development/tools/misc/autoconf { };
all-packages.nix changes for all those updates svn path=/nixpkgs/trunk/; revision=12119
2008-06-16 14:15:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
autoconf213 = callPackage ../development/tools/misc/autoconf/2.13.nix { };
all-packages.nix changes for my last commits svn path=/nixpkgs/trunk/; revision=13693
2009-01-03 13:44:04 +00:00
* aclocal wrapper: skip directories in ACLOCAL_PATH that don't exist, otherwise aclocal barfs. Updated the builder to use makeWrapper * Made Automake 1.10 the default. * Fixed `make check' in Automake by turning off indented logging in Make (there is a flag for that now). * Disabled the `make check' in Automake by default because it takes a REALLY long time (e.g. more than 2 hours on Cygwin, 50 minutes on Darwin, 25 minutes on Linux) which is a lot for a package that otherwise takes 10 seconds to build. We can add a Hydra job with doCheck enabled to do regression testing. * make-wrapper: allow --run commands to add additional flags to the invocation of the wrapped program. An example is the aclocal wrapper: it adds additional -I ... flags. * make-wrapper: call the wrapped program .foo-wrapped instead of .wrapped-foo to make it easier to tell programs apart in `ps' output. svn path=/nixpkgs/branches/stdenv-updates/; revision=14885
2009-04-05 19:13:59 +01:00
automake = automake110x;
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
automake17x = callPackage ../development/tools/misc/automake/automake-1.7.x.nix { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
automake19x = callPackage ../development/tools/misc/automake/automake-1.9.x.nix { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
automake110x = callPackage ../development/tools/misc/automake/automake-1.10.x.nix { };
Add GNU Automake 1.10 (1.9 is kept as the default, though). svn path=/nixpkgs/trunk/; revision=10645
2008-02-12 14:00:26 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
automake111x = callPackage ../development/tools/misc/automake/automake-1.11.x.nix { };
Add GNU Automake 1.11. svn path=/nixpkgs/trunk/; revision=15673
2009-05-20 13:20:51 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
avrdude = callPackage ../development/tools/misc/avrdude { };
added: dnsmasq, uisp, fltk libixp_for_wmii, acerhk kernel module, reiserfsprogs, radeontools, msmtp, procmail, pstree, gxemul changed: umlutilities to also support building tunctl optionally (needing kernel header files) wmii updated and wmiimenu added svn path=/nixpkgs/trunk/; revision=9242
2007-09-03 13:10:57 +01:00
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
binutils = callPackage ../development/tools/misc/binutils {
inherit noSysDirs;
};
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
I removed the function-shape of the cross-toolchain related attributes in the all-packages.nix. That was more complicating than helping. svn path=/nixpkgs/trunk/; revision=20457
2010-03-06 23:36:55 +00:00
binutilsCross = forceBuildDrv (import ../development/tools/misc/binutils {
inherit stdenv fetchurl;
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 08:11:30 +00:00
noSysDirs = true;
Adding assertions for the cross-toolchain attributes, so noone feels tempted to build them without setting a crossSystem to build for. svn path=/nixpkgs/trunk/; revision=20459
2010-03-07 00:05:51 +00: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 19:51:45 +00: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 08:11:30 +00:00
bison: use version 2.3 by default (the latest) svn path=/nixpkgs/trunk/; revision=12703
2008-08-25 14:25:07 +01:00
bison = bison23;
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
bison1875 = callPackage ../development/tools/parsing/bison/bison-1.875.nix { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
bison23 = callPackage ../development/tools/parsing/bison/bison-2.3.nix { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
bison24 = callPackage ../development/tools/parsing/bison/bison-2.4.nix { };
GNU Bison 2.4 (2.3.x remains the default). svn path=/nixpkgs/trunk/; revision=13180
2008-11-03 18:25:17 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
buildbot = callPackage ../development/tools/build-managers/buildbot {
Merge the two BuildBot expressions. svn path=/nixpkgs/trunk/; revision=19358
2010-01-11 17:00:46 +00:00
inherit (pythonPackages) twisted;
Updated scons and twisted; added buildbot. * Updated scons to version 1.0.0. Also added appropriate makeWrapper calls to ensure that the python binary finds its library files. * Updated Twisted from 2.5 to 8.1. * Added an expression for buildbot. svn path=/nixpkgs/trunk/; revision=12782
2008-09-01 16:11:09 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
byacc = callPackage ../development/tools/parsing/byacc { };
Added: * dmenu * gftp * micropolis * byacc as a build-time dependency for micropolis contributed by baldo <baldo@quimby.lan> svn path=/nixpkgs/trunk/; revision=12526
2008-08-06 21:39:01 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
camlp5_strict = callPackage ../development/tools/ocaml/camlp5 { };
Updated Coq to version 8.2pl1 svn path=/nixpkgs/trunk/; revision=18069
2009-11-02 11:44:27 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
camlp5_transitional = callPackage ../development/tools/ocaml/camlp5 {
Updated Coq to version 8.2pl1 svn path=/nixpkgs/trunk/; revision=18069
2009-11-02 11:44:27 +00:00
transitional = 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 17:26:58 +01:00
ccache = callPackage ../development/tools/misc/ccache { };
Add ccache, a compiler cache. svn path=/nixpkgs/trunk/; revision=10644
2008-02-12 13:32:37 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ctags = callPackage ../development/tools/misc/ctags { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
adding ctags-wropped. A wrapper for ctags adding some language (more) language support for .php .js .nix and .as files svn path=/nixpkgs/trunk/; revision=15476
2009-05-06 17:06:45 +01:00
ctagsWrapped = import ../development/tools/misc/ctags/wrapped.nix {
* Remove some incorrect uses of makeOverridable. svn path=/nixpkgs/trunk/; revision=18483
2009-11-20 12:51:14 +00:00
inherit pkgs ctags writeScriptBin;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cmake = callPackage ../development/tools/build-managers/cmake { };
Added cdrkit to burn DVDs. svn path=/nixpkgs/trunk/; revision=8958
2007-07-07 23:31:37 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
coccinelle = callPackage ../development/tools/misc/coccinelle { };
Add Coccinelle, a semantic patch interpreter for C. svn path=/nixpkgs/trunk/; revision=18909
2009-12-12 00:47:14 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cppi = callPackage ../development/tools/misc/cppi { };
Add GNU cppi. svn path=/nixpkgs/trunk/; revision=20363
2010-03-04 11:10:44 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cproto = callPackage ../development/tools/misc/cproto { };
added cproto ( C function prototype generator ) svn path=/nixpkgs/trunk/; revision=11730
2008-04-27 19:20:57 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cflow = callPackage ../development/tools/misc/cflow { };
Add GNU cflow. svn path=/nixpkgs/trunk/; revision=13129
2008-10-28 08:43:44 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cscope = callPackage ../development/tools/misc/cscope { };
Add Cscope, a C code browser. svn path=/nixpkgs/trunk/; revision=12711
2008-08-25 16:34:14 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dejagnu = callPackage ../development/tools/misc/dejagnu { };
Add DejaGNU, a testing framework. svn path=/nixpkgs/trunk/; revision=11623
2008-04-14 12:47:26 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ddd = callPackage ../development/tools/misc/ddd { };
Add "ddd": Graphical front-end for command-line debuggers. svn path=/nixpkgs/trunk/; revision=12336
2008-07-10 17:56:51 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
distcc = callPackage ../development/tools/misc/distcc {
pkgs/top-level/all-packages.nix: prefer makeOverridable over getPkgConfig to customize distcc Changed 'distcc' expression to allow for argument overriding instead of relying on getPkgConfig. svn path=/nixpkgs/trunk/; revision=21866
2010-05-19 13:25:57 +01:00
inherit (gtkLibs) gtk;
static = false;
distcc 3.1: initial version svn path=/nixpkgs/trunk/; revision=17893
2009-10-20 12:54:49 +01:00
};
Added Gajim XMPP client in nearly full-feature configuration with all dependencies svn path=/nixpkgs/trunk/; revision=15001
2009-04-12 20:34:20 +01:00
docutils = builderDefsPackage (import ../development/tools/documentation/docutils) {
inherit python pil makeWrapper;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
doxygen = callPackage ../development/tools/documentation/doxygen {
Doxygen 1.5.8. svn path=/nixpkgs/trunk/; revision=14350
2009-03-05 15:17:53 +00:00
qt = if getPkgConfig "doxygen" "qt4" true then qt4 else null;
Added build expression for doxygen 1.5.7.1. svn path=/nixpkgs/trunk/; revision=13106
2008-10-23 15:23:12 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
eggdbus = callPackage ../development/tools/misc/eggdbus { };
* Added PolicyKit and eggdbus. There is a newer version of PolicyKit (0.93), but it doesn't compile with the current glib. svn path=/nixpkgs/trunk/; revision=16704
2009-08-13 08:55:11 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
elfutils = callPackage ../development/tools/misc/elfutils { };
* Revived RPM. Damn, RPM is nasty to build. svn path=/nixpkgs/trunk/; revision=8407
2007-03-21 19:25:58 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
epm = callPackage ../development/tools/misc/epm { };
* More OpenOffice hackery. Added the magic incantations to get it to install (of course there's no "make install", that would be too easy). Also create some wrapper scripts "oowriter", "oodraw" etc. (I haven't done a full build of this yet, I've hacked on a tmpdir left behind by nix-build -K.) svn path=/nixpkgs/trunk/; revision=9260
2007-09-06 16:00:33 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
emma = callPackage ../development/tools/analysis/emma { };
* Added Emma, a Java code coverage tool. svn path=/nixpkgs/trunk/; revision=10865
2008-02-26 15:48:14 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
findbugs = callPackage ../development/tools/analysis/findbugs { };
* Added Findbugs. svn path=/nixpkgs/trunk/; revision=10854
2008-02-25 14:55:30 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pmd = callPackage ../development/tools/analysis/pmd { };
* added checkstyle, pmd, jdepends. * changed version of ant to 1.7 svn path=/nixpkgs/trunk/; revision=15994
2009-06-18 13:51:51 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jdepend = callPackage ../development/tools/analysis/jdepend { };
* added checkstyle, pmd, jdepends. * changed version of ant to 1.7 svn path=/nixpkgs/trunk/; revision=15994
2009-06-18 13:51:51 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
checkstyle = callPackage ../development/tools/analysis/checkstyle { };
* added checkstyle, pmd, jdepends. * changed version of ant to 1.7 svn path=/nixpkgs/trunk/; revision=15994
2009-06-18 13:51:51 +01:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
flex = flex254a;
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
flex2535 = callPackage ../development/tools/parsing/flex/flex-2.5.35.nix { };
all-packages.nix changes for previous commits svn path=/nixpkgs/trunk/; revision=11217
2008-03-20 09:52:40 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
flex2534 = callPackage ../development/tools/parsing/flex/flex-2.5.34.nix { };
Flex 2.5.34. svn path=/nixpkgs/trunk/; revision=10713
2008-02-16 19:12:55 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
flex2533 = callPackage ../development/tools/parsing/flex/flex-2.5.33.nix { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
Default to Flex 2.5.35; move 2.5.4a out of the way. svn path=/nixpkgs/trunk/; revision=18633
2009-11-25 23:13:28 +00: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 {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit fetchurl stdenv yacc;
Default to Flex 2.5.35; move 2.5.4a out of the way. svn path=/nixpkgs/trunk/; revision=18633
2009-11-25 23:13:28 +00:00
});
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
m4 = gnum4;
* Added wxHaskell. * Added GNU MP, use it in pycrypto. svn path=/nixpkgs/trunk/; revision=7343
2006-12-13 22:29:40 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
global = callPackage ../development/tools/misc/global { };
Add GNU GLOBAL, a source code tag system. svn path=/nixpkgs/trunk/; revision=16333
2009-07-13 10:05:56 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gnum4 = callPackage ../development/tools/misc/gnum4 { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
gnumake = callPackage ../development/tools/build-managers/gnumake { };
Add `gnumakeNix' attribute for GNU Make with `nix-log2xml' support. svn path=/nixpkgs/branches/stdenv-updates/; revision=13055
2008-10-13 10:04:56 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gnumake380 = callPackage ../development/tools/build-managers/gnumake-3.80 { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gradle = callPackage ../development/tools/build-managers/gradle { };
add Gradle 0.8 patch provided by Francois Perrad svn path=/nixpkgs/trunk/; revision=20863
2010-03-30 00:36:35 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gperf = callPackage ../development/tools/misc/gperf { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gtkdialog = callPackage ../development/tools/misc/gtkdialog {
Adding gtkdialog. svn path=/nixpkgs/trunk/; revision=15224
2009-04-21 20:47:30 +01:00
inherit (gtkLibs) gtk;
* added haddock documentation tool for ghc/Haskell svn path=/nixpkgs/trunk/; revision=10229
2008-01-19 17:05:54 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
guileLint = callPackage ../development/tools/guile/guile-lint { };
Add Guile-Lint, a syntax and semantics checker for GNU Guile. svn path=/nixpkgs/trunk/; revision=10710
2008-02-15 16:30:33 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gwrap = callPackage ../development/tools/guile/g-wrap { };
Add G-Wrap, a binding generator for Guile. svn path=/nixpkgs/trunk/; revision=11506
2008-04-09 08:56:52 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
help2man = callPackage ../development/tools/misc/help2man {
* Drop the "perl" prefix from Perl attribute names. It's redundant now that Perl packages are in their own namespace (perlPackages.<pkg>). svn path=/nixpkgs/trunk/; revision=15176
2009-04-20 13:49:35 +01:00
inherit (perlPackages) LocaleGettext;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
iconnamingutils = callPackage ../development/tools/misc/icon-naming-utils {
* Drop the "perl" prefix from Perl attribute names. It's redundant now that Perl packages are in their own namespace (perlPackages.<pkg>). svn path=/nixpkgs/trunk/; revision=15176
2009-04-20 13:49:35 +01:00
inherit (perlPackages) XMLSimple;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
* More Gnome stuff. svn path=/nixpkgs/trunk/; revision=8190
2007-03-05 18:52:31 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
indent = callPackage ../development/tools/misc/indent { };
Added indent svn path=/nixpkgs/trunk/; revision=9790
2007-11-25 18:35:33 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
inotifyTools = callPackage ../development/tools/misc/inotify-tools { };
adding inotify-tools svn path=/nixpkgs/trunk/; revision=19469
2010-01-15 19:35:02 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ired = callPackage ../development/tools/analysis/radare/ired.nix { };
Adding ired, a 'radare' simplification: Interactive Raw Editor. svn path=/nixpkgs/trunk/; revision=20511
2010-03-09 18:14:59 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jikespg = callPackage ../development/tools/parsing/jikespg { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lcov = callPackage ../development/tools/analysis/lcov { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* pam_console needs an old libtool. svn path=/nixpkgs/branches/stdenv-updates/; revision=14791
2009-03-30 16:31:47 +01: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 17:26:58 +01:00
libtool_1_5 = callPackage ../development/tools/misc/libtool { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libtool_2 = callPackage ../development/tools/misc/libtool/libtool2.nix { };
Add GNU Libtool 2.2.x. svn path=/nixpkgs/trunk/; revision=13176
2008-11-03 10:15:37 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lsof = callPackage ../development/tools/misc/lsof { };
Added lsof in package collection svn path=/nixpkgs/trunk/; revision=8886
2007-06-17 23:44:30 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ltrace = callPackage ../development/tools/misc/ltrace { };
Added ltrace - library call tracer. Note that it needed adding an extension point to doUnpack, but it doesn't force full rebuild of everything using builder composing. svn path=/nixpkgs/trunk/; revision=9574
2007-11-03 08:19:00 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mig = callPackage ../os-specific/gnu/mig { };
Add GNU MIG. svn path=/nixpkgs/trunk/; revision=21750
2010-05-12 16:46:43 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mk = callPackage ../development/tools/build-managers/mk { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
noweb = callPackage ../development/tools/literate-programming/noweb { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
omake = callPackage ../development/tools/ocaml/omake { };
omake: version 0.9.8.5 svn path=/nixpkgs/trunk/; revision=22019
2010-05-27 20:44:03 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
openocd = callPackage ../development/tools/misc/openocd { };
Adding OpenOCD. svn path=/nixpkgs/trunk/; revision=17302
2009-09-20 17:43:16 +01:00
Add OProfile, a system-wide profiler for Linux. svn path=/nixpkgs/trunk/; revision=11984
2008-06-04 22:23:30 +01:00
oprofile = import ../development/tools/profiling/oprofile {
OProfile 0.9.6. svn path=/nixpkgs/trunk/; revision=21615
2010-05-05 20:48:18 +01:00
inherit fetchurl stdenv binutils popt makeWrapper gawk which gnugrep;
# Optional build inputs for the (useless) GUI.
/*
qt = qt3;
inherit (xlibs) libX11 libXext;
inherit libpng;
*/
Add OProfile, a system-wide profiler for Linux. svn path=/nixpkgs/trunk/; revision=11984
2008-06-04 22:23:30 +01:00
};
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
patchelf = callPackage ../development/tools/misc/patchelf { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
patchelf06 = callPackage ../development/tools/misc/patchelf/0.6.nix { };
* added patchelf pre-release 0.6 until it gets stable * updated chrome to latest version svn path=/nixpkgs/trunk/; revision=21836
2010-05-18 13:36:23 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pmccabe = callPackage ../development/tools/misc/pmccabe { };
Add pmccabe, a tool that computes the cyclomatic complexity of C/C++ source. svn path=/nixpkgs/trunk/; revision=12000
2008-06-06 13:26:01 +01:00
Made more libraries cross compile. fontconfig, libxcb, bzip2, libdrm, zlib... I was trying to cross compile SDL. Many dependencies work, but I ended seeing libX11 not ready for cross compilation. Other xorg libraries cross-compile well. libX11 may need a small patch. The problem is the usual "configure test cannot be run in cross compilation", so the configure script halts. I made the pkgconfig expression always return buildDrv, as I think it rarely will be needed as buildInput. So to avoid rewriting all its mentions to use it as buildNativeInput, I prefered this small change. svn path=/nixpkgs/branches/stdenv-updates/; revision=18500
2009-11-21 10:44:22 +00:00
/* Make pkgconfig always return a buildDrv, never a proper hostDrv,
because most usage of pkgconfig as buildInput (inheritance of
Adding a note about a change to do in the big-renaming to allow clear buildInputs and buildNativeInputs, on pkgconfig, which now works always as buildDrv even asking for its hostDrv. Key string: cross_renaming svn path=/nixpkgs/branches/stdenv-updates/; revision=18506
2009-11-21 15:39:20 +00:00
pre-cross nixpkgs) means using it using as buildNativeInput
cross_renaming: we should make all programs use pkgconfig as
buildNativeInput after the renaming.
*/
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
pkgconfig = forceBuildDrv (callPackage ../development/tools/misc/pkgconfig { });
Made more libraries cross compile. fontconfig, libxcb, bzip2, libdrm, zlib... I was trying to cross compile SDL. Many dependencies work, but I ended seeing libX11 not ready for cross compilation. Other xorg libraries cross-compile well. libX11 may need a small patch. The problem is the usual "configure test cannot be run in cross compilation", so the configure script halts. I made the pkgconfig expression always return buildDrv, as I think it rarely will be needed as buildInput. So to avoid rewriting all its mentions to use it as buildNativeInput, I prefered this small change. svn path=/nixpkgs/branches/stdenv-updates/; revision=18500
2009-11-21 10:44:22 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
radare = callPackage ../development/tools/analysis/radare {
Adding radare svn path=/nixpkgs/trunk/; revision=15226
2009-04-21 20:47:51 +01:00
inherit (gtkLibs) gtk;
inherit (gnome) vte;
lua = lua5;
Making radare more flexible on build options. svn path=/nixpkgs/trunk/; revision=17294
2009-09-20 10:33:37 +01:00
useX11 = getConfig ["radare" "useX11"] false;
pythonBindings = getConfig ["radare" "pythonBindings"] false;
rubyBindings = getConfig ["radare" "rubyBindings"] false;
luaBindings = getConfig ["radare" "luaBindings"] false;
Adding radare svn path=/nixpkgs/trunk/; revision=15226
2009-04-21 20:47:51 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ragel = callPackage ../development/tools/parsing/ragel { };
Add ragel: A state machine compiler. svn path=/nixpkgs/trunk/; revision=13881
2009-01-27 14:00:54 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
remake = callPackage ../development/tools/build-managers/remake { };
Adding 'remake': a patched and modernized version of GNU make utility that adds improved error reporting, the ability to trace execution in a comprehensible way, and a debugger. svn path=/nixpkgs/trunk/; revision=17744
2009-10-11 16:03:13 +01:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
# couldn't find the source yet
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
seleniumRCBin = callPackage ../development/tools/selenium/remote-control {
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jre = jdk; };
xara update (now works on i686 and _64 again) selenium-rc binaries (automatic web application testing remote control server) svn path=/nixpkgs/trunk/; revision=9835
2007-12-03 14:33:54 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
scons = callPackage ../development/tools/build-managers/scons { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
simpleBuildTool = callPackage ../development/tools/build-managers/simple-build-tool { };
patch provided by David Brown adding simple-build-tool which builds Scala packages svn path=/nixpkgs/trunk/; revision=21671
2010-05-08 22:51:47 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
sloccount = callPackage ../development/tools/misc/sloccount { };
Add SLOCCount, a tool to count source lines of code (SLOCs). svn path=/nixpkgs/trunk/; revision=14091
2009-02-17 10:11:33 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
sparse = callPackage ../development/tools/analysis/sparse { };
Add Sparse, a static analysis tool for C. svn path=/nixpkgs/trunk/; revision=12696
2008-08-22 19:33:52 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
spin = callPackage ../development/tools/analysis/spin { };
Adding spin svn path=/nixpkgs/trunk/; revision=15433
2009-05-03 15:35:43 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
splint = callPackage ../development/tools/analysis/splint { };
Add Splint, a static code analyzer for C. svn path=/nixpkgs/trunk/; revision=12343
2008-07-11 10:13:34 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
strace = callPackage ../development/tools/misc/strace { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
swig = callPackage ../development/tools/misc/swig { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
Keep only one SWIG, with support for all languages. svn path=/nixpkgs/trunk/; revision=17351
2009-09-22 12:59:41 +01: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 17:26:58 +01:00
swftools = callPackage ../tools/video/swftools { };
added swftools svn path=/nixpkgs/trunk/; revision=13078
2008-10-16 12:01:10 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
texinfo49 = callPackage ../development/tools/misc/texinfo/4.9.nix { };
Add GNU Texinfo 4.9, use it to produce GCC 4.x documentation. svn path=/nixpkgs/trunk/; revision=10805
2008-02-21 15:34:56 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
texinfo = callPackage ../development/tools/misc/texinfo { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
texi2html = callPackage ../development/tools/misc/texi2html { };
adding texitohtml (dependency of lilypond) svn path=/nixpkgs/trunk/; revision=17023
2009-09-10 17:57:42 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
uisp = callPackage ../development/tools/misc/uisp { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gdb = callPackage ../development/tools/misc/gdb {
* GDB needs Readline 5. svn path=/nixpkgs/branches/stdenv-updates/; revision=14706
2009-03-25 16:21:25 +00:00
readline = readline5;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gdbCross = callPackage ../development/tools/misc/gdb {
Adding gdbCross, to have a gdb for other targets than native. svn path=/nixpkgs/branches/stdenv-updates/; revision=18772
2009-12-02 20:54:40 +00:00
readline = readline5;
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 17:26:58 +01:00
valgrind = callPackage ../development/tools/analysis/valgrind { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Removed selectVersion. There's no good reason to write `selectVersion ./foo "bar"' instead of `import ./foo/bar.nix'. * Replaced `with args' with formal function arguments in several packages. * Renamed several files to `default.nix'. As a general rule, version numbers should only be included in the filename when there is a reason to keep multiple versions of a package in Nixpkgs. Otherwise, it just makes it harder to update the package. svn path=/nixpkgs/trunk/; revision=18403
2009-11-18 09:39:59 +00:00
xxdiff = builderDefsPackage (import ../development/tools/misc/xxdiff/3.2.nix) {
Added xxdiff svn path=/nixpkgs/trunk/; revision=11888
2008-05-25 21:43:56 +01:00
flex = flex2535;
qt = qt3;
Upgrade default to python version 2.5.x. svn path=/nixpkgs/trunk/; revision=12910
2008-09-24 09:50:32 +01:00
inherit pkgconfig makeWrapper bison python;
Added xxdiff svn path=/nixpkgs/trunk/; revision=11888
2008-05-25 21:43:56 +01:00
inherit (xlibs) libXext libX11;
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
Added xxdiff svn path=/nixpkgs/trunk/; revision=11888
2008-05-25 21:43:56 +01:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
yacc = bison;
added: dnsmasq, uisp, fltk libixp_for_wmii, acerhk kernel module, reiserfsprogs, radeontools, msmtp, procmail, pstree, gxemul changed: umlutilities to also support building tunctl optionally (needing kernel header files) wmii updated and wmiimenu added svn path=/nixpkgs/trunk/; revision=9242
2007-09-03 13:10:57 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
yodl = callPackage ../development/tools/misc/yodl { };
added yodl, dependency for zsh documentation svn path=/nixpkgs/trunk/; revision=13669
2008-12-22 18:36:02 +00:00
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
### DEVELOPMENT / LIBRARIES
Updated gaim to latest beta Added gdb svn path=/nixpkgs/trunk/; revision=8019
2007-02-22 16:07:51 +00:00
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
a52dec = callPackage ../development/libraries/a52dec { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
aalib = callPackage ../development/libraries/aalib { };
* A wrapper around the Visual C++ compiler and the Windows SDK. TODO: download and unpack into the Nix store Visual C++ (either from Visual C++ Express Edition or from the .NET 2.0 Framework SDK) and the Windows Platform SDK. The command line tools don't seem to need any registry settings... svn path=/nixpkgs/trunk/; revision=5369
2006-06-02 10:56:10 +01:00
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
acl = callPackage ../development/libraries/acl { };
Added acl package and fixed attr package. svn path=/nixpkgs/trunk/; revision=9963
2007-12-23 15:09:12 +00:00
* Removed selectVersion. There's no good reason to write `selectVersion ./foo "bar"' instead of `import ./foo/bar.nix'. * Replaced `with args' with formal function arguments in several packages. * Renamed several files to `default.nix'. As a general rule, version numbers should only be included in the filename when there is a reason to keep multiple versions of a package in Nixpkgs. Otherwise, it just makes it harder to update the package. svn path=/nixpkgs/trunk/; revision=18403
2009-11-18 09:39:59 +00:00
adns = import ../development/libraries/adns/1.4.nix {
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
inherit stdenv fetchurl;
static = getPkgConfig "adns" "static" (stdenv ? isStatic || stdenv ? isDietLibC);
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
agg = callPackage ../development/libraries/agg { };
add xchat and tcl svn path=/nixpkgs/trunk/; revision=4302
2005-11-22 12:05:36 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
amrnb = callPackage ../development/libraries/amrnb { };
Adding amr support in mplayer. That should be enabled by the user, because those libraries are not redistributable. I don't know if the 'unfree' in the amr libraries will stop mplayer being built without its support. We would have to write the all-packages MPlayer expression different, in this case. svn path=/nixpkgs/trunk/; revision=17635
2009-10-04 22:31:34 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
amrwb = callPackage ../development/libraries/amrwb { };
Adding amr support in mplayer. That should be enabled by the user, because those libraries are not redistributable. I don't know if the 'unfree' in the amr libraries will stop mplayer being built without its support. We would have to write the all-packages MPlayer expression different, in this case. svn path=/nixpkgs/trunk/; revision=17635
2009-10-04 22:31:34 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
apr = callPackage ../development/libraries/apr { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
aprutil = callPackage ../development/libraries/apr-util {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
bdbSupport = true;
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
aspell = callPackage ../development/libraries/aspell { };
Added acl package and fixed attr package. svn path=/nixpkgs/trunk/; revision=9963
2007-12-23 15:09:12 +00:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
aspellDicts = recurseIntoAttrs (import ../development/libraries/aspell/dictionaries.nix {
inherit fetchurl stdenv aspell which;
});
Added acl package and fixed attr package. svn path=/nixpkgs/trunk/; revision=9963
2007-12-23 15:09:12 +00:00
* More cleanup. Updated to the latest Stratego/XT 0.17. svn path=/nixpkgs/trunk/; revision=14610
2009-03-19 14:34:16 +00:00
aterm = aterm25;
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Sync with the trunk. svn path=/nixpkgs/branches/stdenv-updates/; revision=14634
2009-03-20 16:49:02 +00:00
aterm242fixes = lowPrio (import ../development/libraries/aterm/2.4.2-fixes.nix {
* Oops. svn path=/nixpkgs/trunk/; revision=12213
2008-06-29 18:07:23 +01:00
inherit fetchurl stdenv;
* Sync with the trunk. svn path=/nixpkgs/branches/stdenv-updates/; revision=14634
2009-03-20 16:49:02 +00:00
});
add xchat and tcl svn path=/nixpkgs/trunk/; revision=4302
2005-11-22 12:05:36 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
aterm25 = callPackage ../development/libraries/aterm/2.5.nix { };
* A wrapper around the Visual C++ compiler and the Windows SDK. TODO: download and unpack into the Nix store Visual C++ (either from Visual C++ Express Edition or from the .NET 2.0 Framework SDK) and the Windows Platform SDK. The command line tools don't seem to need any registry settings... svn path=/nixpkgs/trunk/; revision=5369
2006-06-02 10:56:10 +01:00
* Make aterm-2.4.2-fixes the default again, since aterm 2.8 is *still* broken on x86_64. svn path=/nixpkgs/branches/stdenv-updates/; revision=13955
2009-02-02 15:02:42 +00:00
aterm28 = lowPrio (import ../development/libraries/aterm/2.8.nix {
Added aterm 2.5 svn path=/nixpkgs/trunk/; revision=10370
2008-01-29 09:32:56 +00:00
inherit fetchurl stdenv;
* Make aterm-2.4.2-fixes the default again, since aterm 2.8 is *still* broken on x86_64. svn path=/nixpkgs/branches/stdenv-updates/; revision=13955
2009-02-02 15:02:42 +00:00
});
Added aterm 2.5 svn path=/nixpkgs/trunk/; revision=10370
2008-01-29 09:32:56 +00:00
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
attr = callPackage ../development/libraries/attr { };
Added jikes, IBM's open source java compiler. svn path=/nixpkgs/trunk/; revision=715
2004-01-24 22:50:47 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
aubio = callPackage ../development/libraries/aubio { };
adding aubio svn path=/nixpkgs/trunk/; revision=17326
2009-09-21 10:58:38 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
axis = callPackage ../development/libraries/axis { };
Added babl (pixel image transformation library usesd by gegl) svn path=/nixpkgs/trunk/; revision=11460
2008-04-04 16:11:27 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
babl = callPackage ../development/libraries/babl { };
Ruby svn path=/nixpkgs/trunk/; revision=2990
2005-05-05 00:36:28 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
beecrypt = callPackage ../development/libraries/beecrypt { };
Added spidermonkey. svn path=/nixpkgs/trunk/; revision=5227
2006-04-26 15:47:16 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
boehmgc = callPackage ../development/libraries/boehm-gc { };
added version to uuagc added: noweb, lua-5.x, lua-4.x, mk, qc-- (as qcmm) svn path=/nixpkgs/trunk/; revision=4681
2006-02-02 17:07:07 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
boolstuff = callPackage ../development/libraries/boolstuff { };
adding boolstuff svn path=/nixpkgs/trunk/; revision=17026
2009-09-10 17:57:50 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
boost = callPackage ../development/libraries/boost { };
* Provide a patched ATerm library that works on 64-bit systems and on systems with Glibc 2.5 or GCC 4.1.x. svn path=/nixpkgs/trunk/; revision=7032
2006-11-14 15:55:57 +00:00
* Boost: provide a variant boostFull that has all the static, debug, and single-threaded libraries. svn path=/nixpkgs/trunk/; revision=14959
2009-04-09 09:43:46 +01: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;
});
* Provide a patched ATerm library that works on 64-bit systems and on systems with Glibc 2.5 or GCC 4.1.x. svn path=/nixpkgs/trunk/; revision=7032
2006-11-14 15:55:57 +00:00
Updated Monotone to 0.43 svn path=/nixpkgs/trunk/; revision=14704
2009-03-25 16:06:00 +00:00
botan = builderDefsPackage (import ../development/libraries/botan) {
inherit perl;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
buddy = callPackage ../development/libraries/buddy { };
maude, tecla, buddy: new packages Maude is a high-level specification language. Buddy and libtecla are required to build Maude. svn path=/nixpkgs/trunk/; revision=12358
2008-07-15 10:58:30 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cairo = callPackage ../development/libraries/cairo { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cairomm = callPackage ../development/libraries/cairomm { };
cairomm added svn path=/nixpkgs/branches/stdenv-updates/; revision=10477
2008-02-03 13:18:15 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
scmccid = callPackage ../development/libraries/scmccid { };
Adding propietary drivers for the SCM smart card readers. svn path=/nixpkgs/trunk/; revision=19378
2010-01-12 19:22:22 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ccrtp = callPackage ../development/libraries/ccrtp { };
adding twinkle, a voice over IP phone software svn path=/nixpkgs/trunk/; revision=17303
2009-09-20 18:01:19 +01:00
Added chipmunk 2 physics library svn path=/nixpkgs/trunk/; revision=13519
2008-11-30 15:05:43 +00: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 17:26:58 +01:00
chmlib = callPackage ../development/libraries/chmlib { };
Added aspell Added gtkspell Added pidgin, builds but does not run yet: running pidgin fails to find libX11.so.6. ldd on pidgin reports: libX11.so.6 => not found .... libX11.so.6 => /nix/store/brsva6rh1p2ymjvk7054a90is5panrhf-libX11-1.1.1/lib/libX11.so.6 (0xb7358000) which looks a bit weird ... Maybe some problem with patchelf? Or just a build problem and should the library path be set using an environment variable? svn path=/nixpkgs/trunk/; revision=8660
2007-05-13 15:22:24 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cil = callPackage ../development/libraries/cil { };
* aspell: hacked up a little patch to allow additional dictionary directories to be specified through the environment variable ASPELL_EXTRA_DICT_DIRS. This way dictionaries don't have to be installed into aspell's prefix. Instead you can just set ASPELL_EXTRA_DICT_DIRS to $HOME/.nix-profile/lib/aspell and install dictionaries separately with nix-env (e.g. "nix-env -i aspell-dict-nl"). * Added a bunch of Aspell dictionaries. Additional dictionaries can be added easily in development/libraries/aspell/dictionaries.nix. svn path=/nixpkgs/trunk/; revision=9512
2007-10-23 17:33:11 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
cilaterm = callPackage ../development/libraries/cil-aterm {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
stdenv = overrideInStdenv stdenv [gnumake380];
};
added version to uuagc added: noweb, lua-5.x, lua-4.x, mk, qc-- (as qcmm) svn path=/nixpkgs/trunk/; revision=4681
2006-02-02 17:07:07 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
clanlib = callPackage ../development/libraries/clanlib { };
Adding clapack. svn path=/nixpkgs/trunk/; revision=22514
2010-07-07 16:10:01 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
clapack = callPackage ../development/libraries/clapack {
Adding clapack. svn path=/nixpkgs/trunk/; revision=22514
2010-07-07 16:10:01 +01:00
stdenv = stdenv2;
};
add xchat and tcl svn path=/nixpkgs/trunk/; revision=4302
2005-11-22 12:05:36 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
classads = callPackage ../development/libraries/classads { };
applying patches provided by griswold svn path=/nixpkgs/trunk/; revision=19707
2010-01-27 12:12:35 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
classpath = callPackage ../development/libraries/java/classpath {
Add GNU Classpath. svn path=/nixpkgs/trunk/; revision=16527
2009-07-31 10:59:45 +01:00
javac = gcj;
jvm = gcj;
inherit (gtkLibs) gtk;
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 17:26:58 +01:00
clearsilver = callPackage ../development/libraries/clearsilver { };
Added gwydion-dylan to nixpkgs svn path=/nixpkgs/trunk/; revision=1786
2004-11-19 17:47:17 +00:00
Add cln svn path=/nixpkgs/trunk/; revision=23179
2010-08-15 14:54:27 +01:00
cln = callPackage ../development/libraries/cln { };
Changed builderDefs to use composedArgsAndFun, reduced number of nulls, made overrides in builderDefsPackage to work in an intuitive manner. svn path=/nixpkgs/trunk/; revision=12655
2008-08-19 06:54:09 +01:00
clppcre = builderDefsPackage (import ../development/libraries/cl-ppcre) {
};
bison: use version 2.3 by default (the latest) svn path=/nixpkgs/trunk/; revision=12703
2008-08-25 14:25:07 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cluceneCore = callPackage ../development/libraries/clucene-core { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
clutter = callPackage ../development/libraries/clutter {
Add Clutter{,-GTK}, a library for fancy GUIs. svn path=/nixpkgs/trunk/; revision=22648
2010-07-18 23:45:03 +01:00
inherit (gnome) glib pango gtk;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
clutter_gtk = callPackage ../development/libraries/clutter-gtk {
Add Clutter{,-GTK}, a library for fancy GUIs. svn path=/nixpkgs/trunk/; revision=22648
2010-07-18 23:45:03 +01:00
inherit (gnome) 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 17:26:58 +01:00
commoncpp2 = callPackage ../development/libraries/commoncpp2 { };
adding twinkle, a voice over IP phone software svn path=/nixpkgs/trunk/; revision=17303
2009-09-20 18:01:19 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
confuse = callPackage ../development/libraries/confuse { };
Adding xburst-tools to manage the USB_BOOT mode of the Ben Nanonote (reflashing, ...) I add the 'confuse' library as a side effect. svn path=/nixpkgs/trunk/; revision=22817
2010-07-30 00:25:42 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
consolekit = callPackage ../development/libraries/consolekit { };
Added bash 4.0 (and readline 6.0, which is required by bash). svn path=/nixpkgs/trunk/; revision=14573
2009-03-17 14:03:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
coredumper = callPackage ../development/libraries/coredumper { };
add boost svn path=/nixpkgs/trunk/; revision=8874
2007-06-12 16:35:57 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ctl = callPackage ../development/libraries/ctl { };
Lisp isn't a language, it's a building material (Alan Kay). svn path=/nixpkgs/trunk/; revision=1314
2004-08-23 11:44:21 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cppunit = callPackage ../development/libraries/cppunit { };
gimp+php in all-packages svn path=/nixpkgs/trunk/; revision=3808
2005-09-11 23:39:06 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cracklib = callPackage ../development/libraries/cracklib { };
* development/libraries/gnome/*: upgraded all gnome packages to 2.8.3. * development/libraries/gnome/*: copied gtk packages to gnome directory. gnome 2.8.3 did not work on gtk 2.4 nor gtk 2.6. Using the specific version of the gnome platform 2.8.3 directory 'solved' the issue. * development/libraries/gnome/gnome-icon-theme: new packag * development/libraries/gnome/libgtkhtml: new package * development/libraries/gnome/gtkhtml: new package * development/libraries/gnome/libgnomeprint: new package * development/libraries/gnome/libgnomeprintui: new package * development/libraries/gnome/gnome-keyring: new package * development/libraries/gnome/gail: new package * applications/editors/monodoc: new package svn path=/nixpkgs/trunk/; revision=2312
2005-02-26 23:45:19 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cryptopp = callPackage ../development/libraries/crypto++ { };
Add Crypto++, a C++ cryptography library. svn path=/nixpkgs/trunk/; revision=12444
2008-07-29 15:26:03 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cyrus_sasl = callPackage ../development/libraries/cyrus-sasl { };
* Added the j2sdk of Sun for Linux. Downloading this thing is a big problem, so I decided to require to user to get the file and put it in some location in the file system. wget doesn't seem to accept the file scheme however, so I had to move the copying into the builder itself. The builder checks the md5 hash of the downloaded file. Maybe having a separate 'fetchfile' would be useful to make a file in the outside world pure. I tried to add this to build-support, but this obviously did not work. I still committed it. Just remove it if you think that it sucks. svn path=/nixpkgs/trunk/; revision=716
2004-01-24 23:46:00 +00:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
db4 = db45;
add clanlib svn path=/nixpkgs/trunk/; revision=9017
2007-07-22 19:22:46 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
db44 = callPackage ../development/libraries/db4/db4-4.4.nix { };
Added kaffe, in order to have a JVM that can be compiled from source. svn path=/nixpkgs/trunk/; revision=1321
2004-08-23 18:06:50 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
db45 = callPackage ../development/libraries/db4/db4-4.5.nix { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
dbus = callPackage ../development/libraries/dbus {
* DBus 1.1.20. svn path=/nixpkgs/trunk/; revision=10945
2008-03-04 13:30:34 +00:00
useX11 = true; # !!! `false' doesn't build
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Replace some "inherit (gtkLibs) glib" statements with "inherit glib". svn path=/nixpkgs/trunk/; revision=18013
2009-10-29 11:43:02 +00:00
dbus_glib = makeOverridable (import ../development/libraries/dbus-glib) {
inherit fetchurl stdenv pkgconfig gettext dbus expat glib;
Fixed dbus-glib compilation on FreeBSD svn path=/nixpkgs/branches/stdenv-updates/; revision=19793
2010-02-03 20:20:00 +00:00
libiconv = if (stdenv.system == "i686-freebsd") then libiconv else null;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dbus_java = callPackage ../development/libraries/java/dbus-java { };
Added dbus-java and libmatthew-java (dependency for dbus-java) packages svn path=/nixpkgs/trunk/; revision=19170
2010-01-02 13:28:51 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dclib = callPackage ../development/libraries/dclib { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
directfb = callPackage ../development/libraries/directfb { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
dragonegg = callPackage ../development/compilers/llvm/dragonegg.nix {
llvm update attempt + dragonegg svn path=/nixpkgs/trunk/; revision=22234
2010-06-12 18:42:33 +01:00
stdenv = overrideGCC stdenv gcc45;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
enchant = callPackage ../development/libraries/enchant {
* Clean up indentation (expanded tabs etc.). svn path=/nixpkgs/trunk/; revision=11150
2008-03-17 09:41:28 +00:00
inherit (gnome) glib;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
enginepkcs11 = callPackage ../development/libraries/enginepkcs11 { };
Adding engine_pkcs11, a openssl engine for pkcs11 implementations for smartcards. svn path=/nixpkgs/trunk/; revision=19324
2010-01-09 22:22:41 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
esdl = callPackage ../development/libraries/esdl { };
Adding Wings 3D (as a side effect, update erlang, and add esdl). svn path=/nixpkgs/trunk/; revision=22436
2010-07-01 10:08:37 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
exiv2 = callPackage ../development/libraries/exiv2 { };
Added some parts of kde-4. It doesn't work yet, but I need version control svn path=/nixpkgs/trunk/; revision=9049
2007-08-05 14:54:42 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
expat = callPackage ../development/libraries/expat { };
Fixed strategoxt and added the Java packages to all-package-generic svn path=/nixpkgs/trunk/; revision=1256
2004-08-10 12:07:50 +01:00
All-packages.nix updates.. svn path=/nixpkgs/trunk/; revision=14153
2009-02-21 18:59:15 +00:00
extremetuxracer = builderDefsPackage (import ../games/extremetuxracer) {
Use $NIXPKGS_CONFIG to determine whether ghostscript has cups support. svn path=/nixpkgs/trunk/; revision=14275
2009-02-27 13:44:31 +00:00
inherit mesa tcl freeglut SDL SDL_mixer pkgconfig
s/\t/ / Blame Raskin for tabs in all-packages.nix. svn path=/nixpkgs/trunk/; revision=21018
2010-04-11 22:03:59 +01:00
libpng gettext intltool;
All-packages.nix updates.. svn path=/nixpkgs/trunk/; revision=14153
2009-02-21 18:59:15 +00:00
inherit (xlibs) libX11 xproto libXi inputproto
s/\t/ / Blame Raskin for tabs in all-packages.nix. svn path=/nixpkgs/trunk/; revision=21018
2010-04-11 22:03:59 +01:00
libXmu libXext xextproto libXt libSM libICE;
All-packages.nix updates.. svn path=/nixpkgs/trunk/; revision=14153
2009-02-21 18:59:15 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
eventlog = callPackage ../development/libraries/eventlog { };
Added syslog-ng (and the eventlog library that it depends on). svn path=/nixpkgs/trunk/; revision=13988
2009-02-05 16:50:45 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
facile = callPackage ../development/libraries/facile {
* Merged most of the stdenv-updates branch. Some stuff didn't merge cleanly right away (kde-4, kernel stuff) so it should be merged later. But the stdenv stuff is all there. svn path=/nixpkgs/branches/stdenv-updates-merge/; revision=10793
2008-02-20 23:02:41 +00:00
# Actually, we don't need this version but we need native-code compilation
* Make all ocaml versions available in the proper way. svn path=/nixpkgs/trunk/; revision=17805
2009-10-14 16:21:45 +01:00
ocaml = ocaml_3_10_0;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
exrviewer added (needs ctl openexr openexr_ctl) fltk update ilmbase updated ndiswrapper does compile but has to be integrated into the kernel somehow svn path=/nixpkgs/trunk/; revision=9863
2007-12-05 21:25:47 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
faac = callPackage ../development/libraries/faac { };
added faad2 and faac (deps of cinelerra) svn path=/nixpkgs/trunk/; revision=13067
2008-10-14 15:01:38 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
faad2 = callPackage ../development/libraries/faad2 { };
added faad2 and faac (deps of cinelerra) svn path=/nixpkgs/trunk/; revision=13067
2008-10-14 15:01:38 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
farsight2 = callPackage ../development/libraries/farsight2 {
add farsight2 svn path=/nixpkgs/trunk/; revision=19135
2009-12-27 15:27:45 +00:00
inherit (gnome) glib;
inherit (gst_all) gstreamer gstPluginsBase;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
fcgi = callPackage ../development/libraries/fcgi { };
fcgi library added svn path=/nixpkgs/trunk/; revision=10552
2008-02-08 10:54:56 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ffmpeg = callPackage ../development/libraries/ffmpeg { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
fftw = callPackage ../development/libraries/fftw {
fftw also with single support now, new name suffix indecating which one is used svn path=/nixpkgs/trunk/; revision=13064
2008-10-14 14:59:56 +01:00
singlePrecision = false;
};
Fixed Python StringTemplate library. Most importantly, this change required updating the ANTLR 2.x expression to install the Python run-time library. While we're at it, we're building the run-time library for C++ and Java, too. There is still work to be done: the stringtemplate library doesn't find antlr.py without help yet. svn path=/nixpkgs/trunk/; revision=14489
2009-03-10 12:01:22 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
fftwSinglePrec = callPackage ../development/libraries/fftw {
fftw also with single support now, new name suffix indecating which one is used svn path=/nixpkgs/trunk/; revision=13064
2008-10-14 14:59:56 +01:00
singlePrecision = true;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
Added cyrus-sasl-2.1.22 with openssl svn path=/nixpkgs/trunk/; revision=9388
2007-10-01 16:11:38 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
fltk11 = callPackage ../development/libraries/fltk/fltk11.nix { };
Adding cinepaint 0.22.1 and as a dependency, also fltk 1.1.9 svn path=/nixpkgs/trunk/; revision=14841
2009-04-02 16:20:19 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
fltk20 = callPackage ../development/libraries/fltk { };
* Berkeley DB 4.5.20. svn path=/nixpkgs/trunk/; revision=6729
2006-10-13 13:58:13 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
fmod = callPackage ../development/libraries/fmod { };
Adding fmod. svn path=/nixpkgs/trunk/; revision=14193
2009-02-22 22:06:20 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
freeimage = callPackage ../development/libraries/freeimage { };
Committing Lluís Batlle's submissions from mailing list posting <45219fb00901110456i6f21db35tbd1894eaea2146ff@mail.gmail.com>: * nixpkgs-ccrypt-1.7-new.patch * nixpkgs-cmake-add-ccmake.patch * nixpkgs-cpufrequtils-005-new.patch * nixpkgs-dwm-5.1-fix.patch * nixpkgs-freeimage-3.11.0-new.patch * nixpkgs-proxychains-3.1-new.patch * nixpkgs-psi-to-0.12.patch * nixpkgs-skype-to-2.0.0.72.patch * nixpkgs-truecrypt-6.1a-fix.patch * nixpkgs-vxl-1.11.0-new.patch * nixpkgs-xkb-popular-esperanto-symbols.patch * nixpkgs-xorg-via-video-fix.patch svn path=/nixpkgs/trunk/; revision=13751
2009-01-12 21:12:07 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
freetts = callPackage ../development/libraries/freetts { };
Added FreeTTS package svn path=/nixpkgs/trunk/; revision=17577
2009-10-01 15:48:57 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cfitsio = callPackage ../development/libraries/cfitsio { };
cfitsio added svn path=/nixpkgs/trunk/; revision=10350
2008-01-28 19:46:59 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
fontconfig = callPackage ../development/libraries/fontconfig { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Graphviz updated to 2.20.2. Now built with fontconfig, gd and pango support. * New function makeFontsConf to generate a fontconfig configuration file. Moved from NixOS. * dot2pdf: use makeFontsConf to generate a fonts.conf containing just the Ghostscript fonts (see NIXPKGS-29). * dot2pdf: generate PDF directly, don't go through PS. Note that this and using fontconfig changes the interpretation of "fontname" attributes in dot graphs. svn path=/nixpkgs/trunk/; revision=12251
2008-07-03 15:27:19 +01: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 17:26:58 +01:00
freealut = callPackage ../development/libraries/freealut { };
Added dbus variant with X support Default is the old variant (without X). svn path=/nixpkgs/trunk/; revision=9350
2007-09-20 20:40:22 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
freeglut = callPackage ../development/libraries/freeglut { };
* gconf-editor and various dependencies. svn path=/nixpkgs/trunk/; revision=8171
2007-03-04 21:28:24 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
freetype = callPackage ../development/libraries/freetype { };
* gconf-editor and various dependencies. svn path=/nixpkgs/trunk/; revision=8171
2007-03-04 21:28:24 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
fribidi = callPackage ../development/libraries/fribidi { };
Improved Ants in Nix. The names of the various Ants now reflects the j2sdk configuration: ant-j2sdk-1.4.2, ant-j2sdk-1.5.0, ant-blackdown svn path=/nixpkgs/trunk/; revision=1325
2004-08-24 12:26:26 +01:00
Some renaming for future variants svn path=/nixpkgs/trunk/; revision=10343
2008-01-28 19:44:39 +00: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 17:26:58 +01:00
gamin = callPackage ../development/libraries/gamin { };
gamin added svn path=/nixpkgs/trunk/; revision=10337
2008-01-28 19:41:55 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gav = callPackage ../games/gav {
blender update to 2.48 adding some patches to compile dependencies and gav svn path=/nixpkgs/trunk/; revision=15474
2009-05-06 17:06:36 +01:00
stdenv = overrideGCC stdenv gcc41;
Adding GPL Arcade Volleyball. I had this patch _almost_ ready for a long long time. Now ready. svn path=/nixpkgs/trunk/; revision=14017
2009-02-09 22:44:36 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gdbm = callPackage ../development/libraries/gdbm { };
Add GDBM, a key/value database library. svn path=/nixpkgs/trunk/; revision=11480
2008-04-07 00:18:25 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gdk_pixbuf = callPackage ../development/libraries/gdk-pixbuf {
* Getting rid of gtk-libs by moving the packages in gtk-libs to development/libraries/{glib,gtk+,pango,atk,...}. Done for glib/gtk+ 1.2. Also deleted some obsolete, unused versions (gtkLibs 2.10, 2.12, and 2.14). svn path=/nixpkgs/trunk/; revision=17992
2009-10-28 15:06:18 +00:00
inherit (gtkLibs1x) gtk;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gegl = callPackage ../development/libraries/gegl {
gegl added (needs recent glibc) svn path=/nixpkgs/trunk/; revision=11465
2008-04-04 21:57:09 +01:00
# avocodec avformat librsvg
gimp 2.4 -> 2.6 + update dependencies svn path=/nixpkgs/trunk/; revision=13039
2008-10-10 00:21:39 +01:00
inherit (gtkLibs) pango glib gtk;
gegl added (needs recent glibc) svn path=/nixpkgs/trunk/; revision=11465
2008-04-04 21:57:09 +01:00
};
Adding WebDruid log analyzer. In the same time, reworking source autoupdate system a bit svn path=/nixpkgs/trunk/; revision=16859
2009-08-26 12:13:36 +01: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 17:26:58 +01:00
geoipjava = callPackage ../development/libraries/java/geoipjava { };
Added GeoIP Java API library svn path=/nixpkgs/trunk/; revision=21626
2010-05-06 14:58:27 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
geos = callPackage ../development/libraries/geos { };
* DirectFB. svn path=/nixpkgs/trunk/; revision=7040
2006-11-14 22:23:33 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gettext = callPackage ../development/libraries/gettext { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
GNU gettext 0.18 (not in stdenv). svn path=/nixpkgs/trunk/; revision=21704
2010-05-10 13:57:10 +01:00
# XXX: Remove me when `stdenv-updates' is merged.
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gettext_0_18 = callPackage ../development/libraries/gettext/0.18.nix { };
GNU gettext 0.18 (not in stdenv). svn path=/nixpkgs/trunk/; revision=21704
2010-05-10 13:57:10 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gd = callPackage ../development/libraries/gd { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gdal = callPackage ../development/libraries/gdal { };
enchant library added svn path=/nixpkgs/trunk/; revision=9455
2007-10-12 21:27:15 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
giblib = callPackage ../development/libraries/giblib { };
* Added scrot, a command-line screen capture utility. svn path=/nixpkgs/trunk/; revision=16946
2009-09-02 23:56:33 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
glew = callPackage ../development/libraries/glew { };
glew added svn path=/nixpkgs/trunk/; revision=10164
2008-01-16 02:20:46 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
glfw = callPackage ../development/libraries/glfw { };
adding glefw svn path=/nixpkgs/trunk/; revision=18707
2009-11-30 01:05:02 +00:00
* Get rid of the ugly `useFromStdenv' hack in all-packages.nix. Instead, use the generic package override mechanism to use packages from earlier bootstrap phases. * Don't rely on the existence of attributes such as `stdenv.coreutils'. svn path=/nixpkgs/trunk/; revision=22991
2010-08-06 11:34:34 +01:00
glibc = glibc211;
Define "brokenRedHatKernel = true" in $NIXPKGS_CONFIG to build a system that works on Red Hat Linux, i.e. that is based on glibc version 2.5. Furthermore, this patch fixes a number of gcc 4.3.3 build errors in glibc 2.5 that occur on both x86 and x86_64. The older version of this library is still useful for running Nix on a Red Hat host. Newer version of glibc fail to detect the kernel's capabilities correctly (due to mad patches applied to the kernel by Red Hat). The individual changes are: * Re-activated glibc 2.5 in all-packages.nix. * Fix incomplete header search path in bootstrap tools. Gcc-wrapper sets "-B<prefix>" to tell the compiler about its installation root. Unfortunately, the setting doesn't add $gcc/lib/gcc/*/*/include-fixed to the search path. That directory is required, however, because it contains the system-specific "limits.h" file, and the glibc 2.5 builds tries to find that file via #include_next. * Support intrinsic functions like __signbit() or atof() correctly to avoid compile-time conflicts. * Switch to NPTL. Linuxthreads is no longer supported. * Added a meta attribute to glibc package. * Updated nixUnstable to version 0.13pre15614 from trunk. The previous version failed regression tests. * Fix more strict type checking in binutils since 2.18.50.0.3. Without this patch, the build failed on x86, saying: ../sysdeps/i386/fpu/ftestexcept.c: Assembler messages: ../sysdeps/i386/fpu/ftestexcept.c:33: Error: suffix or operands invalid for `fnstsw' svn path=/nixpkgs/branches/stdenv-updates/; revision=16037
2009-06-24 21:10:51 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
glibc25 = callPackage ../development/libraries/glibc-2.5 {
Replace `kernelHeaders' by `linuxHeaders'. svn path=/nixpkgs/branches/stdenv-updates/; revision=19067
2009-12-21 14:04:45 +00:00
kernelHeaders = linuxHeaders;
pkgs/top-level/all-packages.nix: prefer makeOverridable over getConfig to customize libc version Previously, the getConfig variable 'brokenRedHatKernel' was used to switch back to glibc 2.5, which fixes various run-time problems on Red Hat Linux. Now, the same can be achieved by configuring { packageOverrides = pkgs: { glibc = pkgs.useFromStdenv "glibc" pkgs.glibc25; }; } in $NIXPKGS_CONFIG. Similarly, the argument 'installLocales' can be overridden by setting: { packageOverrides = pkgs: { glibc = pkgs.useFromStdenv "glibc" (pkgs.glibc25.override { installLocales = true; }); }; } svn path=/nixpkgs/trunk/; revision=21865
2010-05-19 13:25:54 +01:00
installLocales = false;
Define "brokenRedHatKernel = true" in $NIXPKGS_CONFIG to build a system that works on Red Hat Linux, i.e. that is based on glibc version 2.5. Furthermore, this patch fixes a number of gcc 4.3.3 build errors in glibc 2.5 that occur on both x86 and x86_64. The older version of this library is still useful for running Nix on a Red Hat host. Newer version of glibc fail to detect the kernel's capabilities correctly (due to mad patches applied to the kernel by Red Hat). The individual changes are: * Re-activated glibc 2.5 in all-packages.nix. * Fix incomplete header search path in bootstrap tools. Gcc-wrapper sets "-B<prefix>" to tell the compiler about its installation root. Unfortunately, the setting doesn't add $gcc/lib/gcc/*/*/include-fixed to the search path. That directory is required, however, because it contains the system-specific "limits.h" file, and the glibc 2.5 builds tries to find that file via #include_next. * Support intrinsic functions like __signbit() or atof() correctly to avoid compile-time conflicts. * Switch to NPTL. Linuxthreads is no longer supported. * Added a meta attribute to glibc package. * Updated nixUnstable to version 0.13pre15614 from trunk. The previous version failed regression tests. * Fix more strict type checking in binutils since 2.18.50.0.3. Without this patch, the build failed on x86, saying: ../sysdeps/i386/fpu/ftestexcept.c: Assembler messages: ../sysdeps/i386/fpu/ftestexcept.c:33: Error: suffix or operands invalid for `fnstsw' svn path=/nixpkgs/branches/stdenv-updates/; revision=16037
2009-06-24 21:10:51 +01:00
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
glibc27 = callPackage ../development/libraries/glibc-2.7 {
Replace `kernelHeaders' by `linuxHeaders'. svn path=/nixpkgs/branches/stdenv-updates/; revision=19067
2009-12-21 14:04:45 +00:00
kernelHeaders = linuxHeaders;
* Use Glibc 2.8. svn path=/nixpkgs/branches/stdenv-updates/; revision=12988
2008-10-07 17:55:20 +01:00
#installLocales = false;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
glibc29 = callPackage ../development/libraries/glibc-2.9 {
Replace `kernelHeaders' by `linuxHeaders'. svn path=/nixpkgs/branches/stdenv-updates/; revision=19067
2009-12-21 14:04:45 +00:00
kernelHeaders = linuxHeaders;
* Let's see how far we get with separate locales. svn path=/nixpkgs/branches/stdenv-updates/; revision=15158
2009-04-19 17:07:00 +01:00
installLocales = getPkgConfig "glibc" "locales" false;
* Use Glibc 2.8. svn path=/nixpkgs/branches/stdenv-updates/; revision=12988
2008-10-07 17:55:20 +01:00
};
glibcUnstable: added low-priority expression for the latest glibc 2.8 snapshot svn path=/nixpkgs/trunk/; revision=12315
2008-07-08 00:11:53 +01:00
I removed the function-shape of the cross-toolchain related attributes in the all-packages.nix. That was more complicating than helping. svn path=/nixpkgs/trunk/; revision=20457
2010-03-06 23:36:55 +00: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 19:51:45 +00:00
inherit stdenv fetchurl;
I removed the function-shape of the cross-toolchain related attributes in the all-packages.nix. That was more complicating than helping. svn path=/nixpkgs/trunk/; revision=20457
2010-03-06 23:36:55 +00:00
gccCross = gccCrossStageStatic;
kernelHeaders = linuxHeadersCross;
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 08:11:30 +00:00
installLocales = getPkgConfig "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 19:51:45 +00:00
});
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
glibc211 = callPackage ../development/libraries/glibc-2.11 {
Replace `kernelHeaders' by `linuxHeaders'. svn path=/nixpkgs/branches/stdenv-updates/; revision=19067
2009-12-21 14:04:45 +00:00
kernelHeaders = linuxHeaders;
Add tentative glibc 2.11 expression, based on that of glibc 2.9. svn path=/nixpkgs/branches/stdenv-updates/; revision=18478
2009-11-19 23:28:45 +00:00
installLocales = getPkgConfig "glibc" "locales" false;
* ltrace: updated to 0.5.3. * libdbi / libdbi-drivers: updated to 0.8.3, and make it compile with SQLite. * qemu-image: fix the URL. * gdmap: make it build again (requires an older GTK+). * rlwrap: updated to 0.37. * smbfs-fuse -> fusesmb to match the upstream name. * x11vnc: updated to 0.9.10. * clearlyU: fix the URL. * Various packages: follow the coding conventions. svn path=/nixpkgs/trunk/; revision=22814
2010-07-29 19:55:16 +01:00
machHeaders = null;
hurdHeaders = null;
gccCross = null;
Add tentative glibc 2.11 expression, based on that of glibc 2.9. svn path=/nixpkgs/branches/stdenv-updates/; revision=18478
2009-11-19 23:28:45 +00:00
};
glibc 2.11: Cross-build for GNU/Hurd. svn path=/nixpkgs/trunk/; revision=21752
2010-05-12 16:46:51 +01:00
glibc211Cross = forceBuildDrv (makeOverridable (import ../development/libraries/glibc-2.11)
glibc: Check whether `crossSystem' is null before accessing it. svn path=/nixpkgs/trunk/; revision=21756
2010-05-12 21:49:57 +01:00
(let crossGNU = (crossSystem != null && crossSystem.config == "i586-pc-gnu");
glibc 2.11: Cross-build for GNU/Hurd. svn path=/nixpkgs/trunk/; revision=21752
2010-05-12 16:46:51 +01:00
in ({
inherit stdenv fetchurl;
gccCross = gccCrossStageStatic;
kernelHeaders = if crossGNU then hurdHeaders else linuxHeadersCross;
installLocales = getPkgConfig "glibc" "locales" false;
}
//
(if crossGNU
Remove `migCross' top-level attribute. svn path=/nixpkgs/trunk/; revision=21914
2010-05-20 12:54:31 +01:00
then { inherit machHeaders hurdHeaders mig fetchgit; }
glibc 2.11: Cross-build for GNU/Hurd. svn path=/nixpkgs/trunk/; revision=21752
2010-05-12 16:46:51 +01:00
else { }))));
Fixing a trivial error in the glibc-2.11 longDescription, and fixing the arguments for the ncurses expression. We should find a way to express a dependency in cross compilation of the style "cross-ncurses depends on having the native-ncurses". svn path=/nixpkgs/branches/stdenv-updates/; revision=18479
2009-11-20 08:27:59 +00:00
Enabling cross-builds with uclibc again (I had that too much abandoned). Hydra now should even test it. svn path=/nixpkgs/trunk/; revision=20500
2010-03-09 15:48:25 +00:00
glibcCross = glibc211Cross;
Making the cross-builds work with uclibc. There is no easy way of switching between uclibc/glibc still. I started the renaming from glibc to libc regarding the cross-toolchain, but I still have to finish. svn path=/nixpkgs/branches/stdenv-updates/; revision=18801
2009-12-04 13:35:58 +00:00
# We can choose:
Enabling cross-builds with uclibc again (I had that too much abandoned). Hydra now should even test it. svn path=/nixpkgs/trunk/; revision=20500
2010-03-09 15:48:25 +00:00
libcCrossChooser = name : if (name == "glibc") then glibcCross
else if (name == "uclibc") then uclibcCross
Making wxGTK stay wxGTK even cross-built, so I remove the wxMSW code I added to test the crossbuilding with wxGTK. I added a new windows-specific package: wxMSW. svn path=/nixpkgs/trunk/; revision=21634
2010-05-06 20:19:22 +01:00
else if (name == "msvcrt") then windows.mingw_headers3
Enabling cross-builds with uclibc again (I had that too much abandoned). Hydra now should even test it. svn path=/nixpkgs/trunk/; revision=20500
2010-03-09 15:48:25 +00:00
else throw "Unknown libc";
Fixing the evaluation of trunk (regarding reenabling uclibc cross builds) svn path=/nixpkgs/trunk/; revision=20509
2010-03-09 18:05:33 +00: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 08:11:30 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libdbusmenu_qt = callPackage ../development/libraries/libdbusmenu-qt { };
Add libdbusmenu-qt svn path=/nixpkgs/trunk/; revision=22450
2010-07-04 21:55:50 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libdwg = callPackage ../development/libraries/libdwg { };
adding libdwg - optional dependency of grass svn path=/nixpkgs/trunk/; revision=21736
2010-05-12 01:50:01 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
eglibc = callPackage ../development/libraries/eglibc {
Replace `kernelHeaders' by `linuxHeaders'. svn path=/nixpkgs/branches/stdenv-updates/; revision=19067
2009-12-21 14:04:45 +00:00
kernelHeaders = linuxHeaders;
Porting changes from stdenv-updates into this branch. This comes from: svn diff ^/nixpkgs/trunk/@18255 ^/nixpkgs/branches/stdenv-updates/ > diff patch -p0 < diff and then adding into svn all files new from the patch. trunk@18255 comes from the last time I updated stdenv-updates from trunk. svn path=/nixpkgs/stdenv-updates2/; revision=18272
2009-11-08 00:32:12 +00:00
installLocales = getPkgConfig "glibc" "locales" 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 17:26:58 +01:00
glibcLocales = callPackage ../development/libraries/glibc-2.11/locales.nix { };
* A function to build Glibc's locale-archive separately from Glibc. svn path=/nixpkgs/branches/stdenv-updates/; revision=15155
2009-04-19 16:28:37 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
glibcInfo = callPackage ../development/libraries/glibc-2.11/info.nix { };
First attempt at adding an attribute for the libc.info glibc manual. svn path=/nixpkgs/trunk/; revision=17868
2009-10-18 16:15:39 +01:00
Improved support for building 32-bit binaries on x86_64-linux. * glibc_multi: a wrapper that combines the 32-bit and 64-bit Glibcs. This is necessary so that 64-bit GCC can find gnu/stubs-32.h and the 32-bit Glibc libraries. To build glibc_multi on x86_64-linux, you still need either the i686-linux Glibc derivation from a channel, or to have configured Nix with support for forwarding the build to a i686-linux machine. In the future this may become unnecessary by providing a prebuilt binary of 32-bit Glibc somewhere (like the binaries used in the stdenvLinux bootstrap). * With glibc_multi, it becomes possible to build gcc with multilib support (i.e. it builds 32-bit and 64-bit versions of libgcc, libstdc++, etc.). svn path=/nixpkgs/trunk/; revision=12203
2008-06-27 19:26:19 +01:00
glibc_multi =
Try selecting packages to build based on their being maintained svn path=/nixpkgs/trunk/; revision=16844
2009-08-25 06:46:48 +01:00
runCommand "${glibc.name}-multi"
{ glibc64 = glibc;
glibc32 = (import ./all-packages.nix {system = "i686-linux";}).glibc;
}
''
ensureDir $out
ln -s $glibc64/* $out/
rm $out/lib $out/lib64
ensureDir $out/lib
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
'' # */
Trying to reinstate the meta-based Hydra builds svn path=/nixpkgs/trunk/; revision=16883
2009-08-28 07:29:21 +01:00
;
Improved support for building 32-bit binaries on x86_64-linux. * glibc_multi: a wrapper that combines the 32-bit and 64-bit Glibcs. This is necessary so that 64-bit GCC can find gnu/stubs-32.h and the 32-bit Glibc libraries. To build glibc_multi on x86_64-linux, you still need either the i686-linux Glibc derivation from a channel, or to have configured Nix with support for forwarding the build to a i686-linux machine. In the future this may become unnecessary by providing a prebuilt binary of 32-bit Glibc somewhere (like the binaries used in the stdenvLinux bootstrap). * With glibc_multi, it becomes possible to build gcc with multilib support (i.e. it builds 32-bit and 64-bit versions of libgcc, libstdc++, etc.). svn path=/nixpkgs/trunk/; revision=12203
2008-06-27 19:26:19 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
glpk = callPackage ../development/libraries/glpk { };
Add the GNU Linear Programming Kit (GLPK). Contributed by Brian Gough <bjg@gnu.org>. svn path=/nixpkgs/trunk/; revision=21284
2010-04-23 22:15:48 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gmime = callPackage ../development/libraries/gmime { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gmime_2_2 = callPackage ../development/libraries/gmime/2.2.x.nix { };
* Revive gmime-2.2.x, because gmime-2.4.x is not backwards compatible. For instance, Pan requires gmime-2.2. svn path=/nixpkgs/trunk/; revision=22543
2010-07-09 10:12:42 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gmm = callPackage ../development/libraries/gmm { };
kde shipped with a copy of this lib. They have removed it. I guess we need id nevertheless? svn path=/nixpkgs/trunk/; revision=11669
2008-04-21 16:20:49 +01:00
pkgs/applications/editors/emacs-modes/magit: updated to version magit-0.7-94-gbf42bf8 Magit has seen plenty of development since version 0.7, but for some reason there haven't been any new releases. This version bump updates the expression to build a current version of Magit directly from the Git repository. This change adds buildInputs 'autoconf' and 'automake'. These tools are required only because we aren't building from a proper release tarball. Once version 0.8 comes out, these dependencies can be dropped again. svn path=/nixpkgs/trunk/; revision=20650
2010-03-16 12:13:40 +00:00
gmp =
use gmp 4.3.2 on i686-darwin svn path=/nixpkgs/trunk/; revision=19864
2010-02-08 13:58:25 +00:00
if stdenv.system == "i686-darwin" then
* Incorrect filename: 4.3.2 -> 4.3.1 svn path=/nixpkgs/trunk/; revision=19869
2010-02-08 17:46:34 +00:00
# GMP 4.3.2 is broken on Darwin, so use 4.3.1.
makeOverridable (import ../development/libraries/gmp/4.3.1.nix) {
use gmp 4.3.2 on i686-darwin svn path=/nixpkgs/trunk/; revision=19864
2010-02-08 13:58:25 +00:00
inherit stdenv fetchurl m4;
cxx = false;
}
pkgs/applications/editors/emacs-modes/magit: updated to version magit-0.7-94-gbf42bf8 Magit has seen plenty of development since version 0.7, but for some reason there haven't been any new releases. This version bump updates the expression to build a current version of Magit directly from the Git repository. This change adds buildInputs 'autoconf' and 'automake'. These tools are required only because we aren't building from a proper release tarball. Once version 0.8 comes out, these dependencies can be dropped again. svn path=/nixpkgs/trunk/; revision=20650
2010-03-16 12:13:40 +00:00
else
use gmp 4.3.2 on i686-darwin svn path=/nixpkgs/trunk/; revision=19864
2010-02-08 13:58:25 +00:00
makeOverridable (import ../development/libraries/gmp) {
inherit stdenv fetchurl m4;
cxx = false;
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Fix gmpxx. svn path=/nixpkgs/branches/stdenv-updates/; revision=19550
2010-01-19 17:44:59 +00:00
gmpxx = gmp.override { cxx = true; };
all-packages.nix: added 'gmpxx', a reference to libgmp with C++ API enabled svn path=/nixpkgs/trunk/; revision=16158
2009-07-03 12:31:28 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gobjectIntrospection = callPackage ../development/libraries/gobject-introspection { };
Add gobject-introspection svn path=/nixpkgs/trunk/; revision=21763
2010-05-13 16:56:04 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
goffice = callPackage ../development/libraries/goffice {
Add GOffice, GNOME's office/document library. svn path=/nixpkgs/trunk/; revision=17550
2009-09-30 14:11:13 +01:00
inherit (gnome) glib gtk libglade libgnomeui pango;
gconf = gnome.GConf;
libart = gnome.libart_lgpl;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
goocanvas = callPackage ../development/libraries/goocanvas {
added goocanvas svn path=/nixpkgs/trunk/; revision=13552
2008-12-02 12:28:13 +00:00
inherit (gnome) gtk glib;
};
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00: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 17:26:58 +01:00
mpfr = callPackage ../development/libraries/mpfr { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
gstreamer update (needed by gstPython) dropping dep gnomevfs (see code commment) svn path=/nixpkgs/trunk/; revision=13344
2008-11-19 21:46:01 +00:00
gst_all = recurseIntoAttrs (import ../development/libraries/gstreamer {
* Removed selectVersion. There's no good reason to write `selectVersion ./foo "bar"' instead of `import ./foo/bar.nix'. * Replaced `with args' with formal function arguments in several packages. * Renamed several files to `default.nix'. As a general rule, version numbers should only be included in the filename when there is a reason to keep multiple versions of a package in Nixpkgs. Otherwise, it just makes it harder to update the package. svn path=/nixpkgs/trunk/; revision=18403
2009-11-18 09:39:59 +00:00
inherit lib stdenv fetchurl perl bison pkgconfig libxml2
- svn path=/nixpkgs/branches/stdenv-updates-merge/; revision=10823
2008-02-22 03:06:12 +00:00
python alsaLib cdparanoia libogg libvorbis libtheora freetype liboil
libjpeg zlib speex libpng libdv aalib cairo libcaca flac hal libiec61883
Fix GStreamer 'good' plugins svn path=/nixpkgs/trunk/; revision=18952
2009-12-15 07:47:45 +00:00
dbus libavc1394 ladspaH taglib pulseaudio gdbm bzip2 which makeOverridable
Adding libtasn1 dependency for gst-plugins svn path=/nixpkgs/trunk/; revision=18956
2009-12-15 09:37:42 +00:00
libcap libtasn1;
gstreamer update (needed by gstPython) dropping dep gnomevfs (see code commment) svn path=/nixpkgs/trunk/; revision=13344
2008-11-19 21:46:01 +00:00
flex = flex2535;
- svn path=/nixpkgs/branches/stdenv-updates-merge/; revision=10823
2008-02-22 03:06:12 +00:00
inherit (xorg) libX11 libXv libXext;
inherit (gtkLibs) glib pango gtk;
gstreamer update (needed by gstPython) dropping dep gnomevfs (see code commment) svn path=/nixpkgs/trunk/; revision=13344
2008-11-19 21:46:01 +00:00
inherit (gnome) gnomevfs /* <- only passed for the no longer used older versions
Try removing gnome26 references svn path=/nixpkgs/branches/xorg-7.5/; revision=18086
2009-11-04 00:39:27 +00:00
it is deprecated and didn't build on amd64 due to samba dependency */ gtkdoc
s/\t/ / Blame Raskin for tabs in all-packages.nix. svn path=/nixpkgs/trunk/; revision=21018
2010-04-11 22:03:59 +01:00
libsoup;
gstreamer update (needed by gstPython) dropping dep gnomevfs (see code commment) svn path=/nixpkgs/trunk/; revision=13344
2008-11-19 21:46:01 +00:00
});
- svn path=/nixpkgs/branches/stdenv-updates-merge/; revision=10823
2008-02-22 03:06:12 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gnet = callPackage ../development/libraries/gnet { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gnutls = callPackage ../development/libraries/gnutls {
GnuTLS 2.6.6, with Guile bindings by default. svn path=/nixpkgs/trunk/; revision=15416
2009-04-30 19:43:48 +01:00
guileBindings = getConfig ["gnutls" "guile"] true;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gpgme = callPackage ../development/libraries/gpgme { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gsasl = callPackage ../development/libraries/gsasl { };
Add GNU SASL, GNU GSS-API, and GNU Rush. Contributed by Brian Gough <bjg@gnu.org>. svn path=/nixpkgs/trunk/; revision=21315
2010-04-26 09:59:25 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gsl = callPackage ../development/libraries/gsl { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gsoap = callPackage ../development/libraries/gsoap { };
applying patches provided by griswold svn path=/nixpkgs/trunk/; revision=19707
2010-01-27 12:12:35 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gss = callPackage ../development/libraries/gss { };
Add GNU SASL, GNU GSS-API, and GNU Rush. Contributed by Brian Gough <bjg@gnu.org>. svn path=/nixpkgs/trunk/; revision=21315
2010-04-26 09:59:25 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gtkimageview = callPackage ../development/libraries/gtkimageview {
Add GtkImageView. svn path=/nixpkgs/trunk/; revision=17880
2009-10-19 13:50:41 +01:00
inherit (gnome) gtk;
};
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01:00
gtkLibs = gtkLibs220;
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Replace some "inherit (gtkLibs) glib" statements with "inherit glib". svn path=/nixpkgs/trunk/; revision=18013
2009-10-29 11:43:02 +00:00
glib = gtkLibs.glib;
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01:00
gtkLibs1x = recurseIntoAttrs (let callPackage = newScope pkgs.gtkLibs1x; in rec {
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
glib = callPackage ../development/libraries/glib/1.2.x.nix { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gtk = callPackage ../development/libraries/gtk+/1.2.x.nix { };
pkgs/tools/typesetting/asciidoc: updated to version 8.5.1 New asciidoc versions do have a proper configure script. Using that simplifies the build instructions a bit. svn path=/nixpkgs/trunk/; revision=18076
2009-11-03 15:57:22 +00:00
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01:00
});
GTK+ 2.14.7 and companion libraries. svn path=/nixpkgs/trunk/; revision=13821
2009-01-22 22:32:02 +00:00
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01:00
gtkLibs216 = recurseIntoAttrs (let callPackage = newScope pkgs.gtkLibs216; in rec {
* Idem for gtk-libs/2.16. svn path=/nixpkgs/trunk/; revision=17993
2009-10-28 15:31:52 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
glib = callPackage ../development/libraries/glib/2.20.x.nix { };
* Idem for gtk-libs/2.16. svn path=/nixpkgs/trunk/; revision=17993
2009-10-28 15:31:52 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
glibmm = callPackage ../development/libraries/glibmm/2.18.x.nix { };
* Idem for gtk-libs/2.16. svn path=/nixpkgs/trunk/; revision=17993
2009-10-28 15:31:52 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
atk = callPackage ../development/libraries/atk/1.24.x.nix { };
* Idem for gtk-libs/2.16. svn path=/nixpkgs/trunk/; revision=17993
2009-10-28 15:31:52 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pango = callPackage ../development/libraries/pango/1.24.x.nix { };
* Idem for gtk-libs/2.16. svn path=/nixpkgs/trunk/; revision=17993
2009-10-28 15:31:52 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pangomm = callPackage ../development/libraries/pangomm/2.14.x.nix { };
* Idem for gtk-libs/2.16. svn path=/nixpkgs/trunk/; revision=17993
2009-10-28 15:31:52 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gtk = callPackage ../development/libraries/gtk+/2.16.x.nix { };
pkgs/tools/typesetting/asciidoc: updated to version 8.5.1 New asciidoc versions do have a proper configure script. Using that simplifies the build instructions a bit. svn path=/nixpkgs/trunk/; revision=18076
2009-11-03 15:57:22 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gtkmm = callPackage ../development/libraries/gtkmm/2.14.x.nix { };
pkgs/tools/typesetting/asciidoc: updated to version 8.5.1 New asciidoc versions do have a proper configure script. Using that simplifies the build instructions a bit. svn path=/nixpkgs/trunk/; revision=18076
2009-11-03 15:57:22 +00:00
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01:00
});
GTK+ 2.16 and companion libraries. svn path=/nixpkgs/branches/stdenv-updates/; revision=15079
2009-04-16 11:19:15 +01:00
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01:00
gtkLibs218 = recurseIntoAttrs (let callPackage = newScope pkgs.gtkLibs218; in rec {
* Finished getting rid of gtk-libs. svn path=/nixpkgs/trunk/; revision=18010
2009-10-29 10:53:54 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
glib = callPackage ../development/libraries/glib/2.22.x.nix {
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01:00
libiconv = if stdenv.system == "i686-freebsd" then libiconv else null;
* Finished getting rid of gtk-libs. svn path=/nixpkgs/trunk/; revision=18010
2009-10-29 10:53:54 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
glibmm = callPackage ../development/libraries/glibmm/2.22.x.nix { };
* Finished getting rid of gtk-libs. svn path=/nixpkgs/trunk/; revision=18010
2009-10-29 10:53:54 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
atk = callPackage ../development/libraries/atk/1.28.x.nix { };
* Finished getting rid of gtk-libs. svn path=/nixpkgs/trunk/; revision=18010
2009-10-29 10:53:54 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pango = callPackage ../development/libraries/pango/1.26.x.nix { };
* Finished getting rid of gtk-libs. svn path=/nixpkgs/trunk/; revision=18010
2009-10-29 10:53:54 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pangomm = callPackage ../development/libraries/pangomm/2.26.x.nix { };
* Finished getting rid of gtk-libs. svn path=/nixpkgs/trunk/; revision=18010
2009-10-29 10:53:54 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gtk = callPackage ../development/libraries/gtk+/2.18.x.nix { };
pkgs/tools/typesetting/asciidoc: updated to version 8.5.1 New asciidoc versions do have a proper configure script. Using that simplifies the build instructions a bit. svn path=/nixpkgs/trunk/; revision=18076
2009-11-03 15:57:22 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gtkmm = callPackage ../development/libraries/gtkmm/2.18.x.nix { };
pkgs/tools/typesetting/asciidoc: updated to version 8.5.1 New asciidoc versions do have a proper configure script. Using that simplifies the build instructions a bit. svn path=/nixpkgs/trunk/; revision=18076
2009-11-03 15:57:22 +00:00
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01:00
});
Mentioning GTK-2.18 in all-packages svn path=/nixpkgs/trunk/; revision=17502
2009-09-29 14:49:41 +01:00
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01:00
gtkLibs220 = recurseIntoAttrs (let callPackage = newScope pkgs.gtkLibs220; in rec {
* GTK+ 2.20, Glib 2.24 etc. svn path=/nixpkgs/branches/x-updates/; revision=22652
2010-07-19 00:22:59 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
glib = callPackage ../development/libraries/glib/2.24.x.nix {
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01:00
libiconv = if stdenv.system == "i686-freebsd" then libiconv else null;
* GTK+ 2.20, Glib 2.24 etc. svn path=/nixpkgs/branches/x-updates/; revision=22652
2010-07-19 00:22:59 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
glibmm = callPackage ../development/libraries/glibmm/2.22.x.nix { };
* GTK+ 2.20, Glib 2.24 etc. svn path=/nixpkgs/branches/x-updates/; revision=22652
2010-07-19 00:22:59 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
atk = callPackage ../development/libraries/atk/1.30.x.nix { };
* GTK+ 2.20, Glib 2.24 etc. svn path=/nixpkgs/branches/x-updates/; revision=22652
2010-07-19 00:22:59 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pango = callPackage ../development/libraries/pango/1.28.x.nix { };
* GTK+ 2.20, Glib 2.24 etc. svn path=/nixpkgs/branches/x-updates/; revision=22652
2010-07-19 00:22:59 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pangomm = callPackage ../development/libraries/pangomm/2.26.x.nix { };
* GTK+ 2.20, Glib 2.24 etc. svn path=/nixpkgs/branches/x-updates/; revision=22652
2010-07-19 00:22:59 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gtk = callPackage ../development/libraries/gtk+/2.20.x.nix { };
* GTK+ 2.20, Glib 2.24 etc. svn path=/nixpkgs/branches/x-updates/; revision=22652
2010-07-19 00:22:59 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gtkmm = callPackage ../development/libraries/gtkmm/2.18.x.nix { };
* GTK+ 2.20, Glib 2.24 etc. svn path=/nixpkgs/branches/x-updates/; revision=22652
2010-07-19 00:22:59 +01:00
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01:00
});
* GTK+ 2.20, Glib 2.24 etc. svn path=/nixpkgs/branches/x-updates/; revision=22652
2010-07-19 00:22:59 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gtkmozembedsharp = callPackage ../development/libraries/gtkmozembed-sharp {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gnome) gtk;
gtksharp = gtksharp2;
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gtksharp1 = callPackage ../development/libraries/gtk-sharp-1 {
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
inherit (gnome) gtk glib pango libglade libgtkhtml gtkhtml
libgnomecanvas libgnomeui libgnomeprint
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
libgnomeprintui GConf;
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gtksharp2 = callPackage ../development/libraries/gtk-sharp-2 {
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
inherit (gnome) gtk glib pango libglade libgtkhtml gtkhtml
libgnomecanvas libgnomeui libgnomeprint
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
libgnomeprintui GConf gnomepanel;
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gtksourceviewsharp = callPackage ../development/libraries/gtksourceview-sharp {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gnome) gtksourceview;
gtksharp = gtksharp2;
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gtkspell = callPackage ../development/libraries/gtkspell {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gtkLibs) gtk;
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
Some renaming for future variants svn path=/nixpkgs/trunk/; revision=10343
2008-01-28 19:44:39 +00:00
# TODO : Add MIT Kerberos and let admin choose.
kerberos = heimdal;
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
heimdal = callPackage ../development/libraries/kerberos/heimdal.nix { };
Heimdal Kerberos added svn path=/nixpkgs/trunk/; revision=10336
2008-01-28 19:41:25 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
hsqldb = callPackage ../development/libraries/java/hsqldb { };
Added exiv2-0.15 library svn path=/nixpkgs/trunk/; revision=9389
2007-10-01 16:12:41 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
hunspell = callPackage ../development/libraries/hunspell { };
Add hunspell TODO: make it work (export DICTDIR) svn path=/nixpkgs/trunk/; revision=22432
2010-06-30 16:53:28 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
hwloc = callPackage ../development/libraries/hwloc { };
Add hwloc 0.9.2, renamed from libtopology. svn path=/nixpkgs/trunk/; revision=18152
2009-11-05 18:46:46 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
hydraAntLogger = callPackage ../development/libraries/java/hydra-ant-logger { };
hydra-ant-logger svn path=/nixpkgs/trunk/; revision=20332
2010-03-02 15:37:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
icu = callPackage ../development/libraries/icu { };
Added Apache Ant, including configuration of JAVA_HOME and ANT_HOME. Currently only the shell script is patched, but this one is used most in practice. svn path=/nixpkgs/trunk/; revision=718
2004-01-25 00:50:00 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
id3lib = callPackage ../development/libraries/id3lib { };
Added facile library svn path=/nixpkgs/trunk/; revision=9674
2007-11-14 23:05:11 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ilbc = callPackage ../development/libraries/ilbc { };
ilbc and msilbc libraries added svn path=/nixpkgs/branches/stdenv-updates/; revision=10570
2008-02-10 17:35:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ilmbase = callPackage ../development/libraries/ilmbase { };
enable beecrypt here svn path=/nixpkgs/trunk/; revision=4402
2005-12-19 18:56:31 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
imlib = callPackage ../development/libraries/imlib { };
sox, ffmpeg_svn expressions added ghcPkgUtil defines a function to create setup-hook - creating a packagedatabase (nix-support/package.conf) - adding it to GHC_PACKAGE_PATH see comments for details svn path=/nixpkgs/trunk/; revision=9500
2007-10-22 01:51:40 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
imlib2 = callPackage ../development/libraries/imlib2 { };
Added a new setup proposal, builder is no more derived from shell script (where edit=glibc rebuild), but is composed from a nix attribute set with strings and dependencies - so if you add a function, old expressions ignore it; collateral damage are packages in this style: Fastest Fourier Transform in the West, Audacity sound editor, Falling Sand game. Also added string equality that ignores dependencies to lib. Note that hasSuffixHack is now the more predictable version, but hasSuffix is left to remind us to fix the bug. svn path=/nixpkgs/trunk/; revision=9549
2007-10-29 10:52:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
indilib = callPackage ../development/libraries/indilib { };
indilib added svn path=/nixpkgs/trunk/; revision=10352
2008-01-28 19:47:23 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
iniparser = callPackage ../development/libraries/iniparser { };
iniparser library added svn path=/nixpkgs/trunk/; revision=10344
2008-01-28 19:45:19 +00:00
* intltool: deleted redundant copy (it's already in the Gnome Nix expressions). * Fixed xkbcomp: it no longer found the keyboard definitions since it disregards the -R option passed by the X server (it chdirs to the -R path, but "." has been removed from the xkbcomp search path in xkbcomp 1.0.5). Build it with /etc/X11/xkb as its default location. This is less pure but it does allow for updating xkeyboard-config in a running server. * xkeyboard-config: updated to 1.4. svn path=/nixpkgs/branches/stdenv-updates/; revision=13018
2008-10-09 13:12:58 +01:00
intltool = gnome.intltool;
added: dnsmasq, uisp, fltk libixp_for_wmii, acerhk kernel module, reiserfsprogs, radeontools, msmtp, procmail, pstree, gxemul changed: umlutilities to also support building tunctl optionally (needing kernel header files) wmii updated and wmiimenu added svn path=/nixpkgs/trunk/; revision=9242
2007-09-03 13:10:57 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
isocodes = callPackage ../development/libraries/iso-codes { };
all-packages.nix: commented out package 'vice' error: getting status of `/usr/local/src/nix-pkgs-current/pkgs/misc/emulators/vice': No such file or directory svn path=/nixpkgs/trunk/; revision=15646
2009-05-18 14:53:01 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
itk = callPackage ../development/libraries/itk { };
Adding the itk libraries. Adding a skeleton of the seg3d package. It builds, but libraries and rpaths are wrong. I hope to fix it soon. svn path=/nixpkgs/trunk/; revision=20320
2010-03-01 23:31:35 +00:00
Adding JAMP game.. svn path=/nixpkgs/trunk/; revision=18454
2009-11-19 12:10:23 +00: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 17:26:58 +01:00
jasper = callPackage ../development/libraries/jasper { };
pkgs/tools/typesetting/asciidoc: updated to version 8.5.1 New asciidoc versions do have a proper configure script. Using that simplifies the build instructions a bit. svn path=/nixpkgs/trunk/; revision=18076
2009-11-03 15:57:22 +00:00
Adding 'mupdf', a lightweight PDF 1.7 viewer As a side effect, I add openjpeg and jbig2dec. svn path=/nixpkgs/trunk/; revision=23069
2010-08-09 21:59:38 +01: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 17:26:58 +01:00
jetty_gwt = callPackage ../development/libraries/java/jetty-gwt { };
pkgs/tools/typesetting/asciidoc: updated to version 8.5.1 New asciidoc versions do have a proper configure script. Using that simplifies the build instructions a bit. svn path=/nixpkgs/trunk/; revision=18076
2009-11-03 15:57:22 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jetty_util = callPackage ../development/libraries/java/jetty-util { };
Added JasPer JPEG 2000 library svn path=/nixpkgs/trunk/; revision=10335
2008-01-28 19:41:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
judy = callPackage ../development/libraries/judy { };
Making gtkwave more featured, adding more buildInputs. svn path=/nixpkgs/trunk/; revision=22133
2010-06-03 16:37:02 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
krb5 = callPackage ../development/libraries/kerberos/krb5.nix { };
Add MIT Kerberos implementation krb5. svn path=/nixpkgs/trunk/; revision=18202
2009-11-06 12:57:29 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
lablgtk = callPackage ../development/libraries/lablgtk {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gtkLibs) gtk;
Added Monotone-Viz, viewer for monotone histories. svn path=/nixpkgs/trunk/; revision=12034
2008-06-11 07:12:18 +01:00
inherit (gnome) libgnomecanvas;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
* CIL 1.3.2 svn path=/nixpkgs/trunk/; revision=3016
2005-05-09 16:56:34 +01:00
Add lcms2 svn path=/nixpkgs/trunk/; revision=23012
2010-08-06 21:23:56 +01:00
lcms = lcms1;
lcms1 = callPackage ../development/libraries/lcms { };
lcms2 = callPackage ../development/libraries/lcms2 { };
* Added GemRB, a reimplementation of the Infinity Engine. svn path=/nixpkgs/trunk/; revision=8695
2007-05-14 22:47:11 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
lensfun = callPackage ../development/libraries/lensfun {
Add lensfun library svn path=/nixpkgs/trunk/; revision=21560
2010-05-03 04:45:52 +01: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 17:26:58 +01:00
lesstif = callPackage ../development/libraries/lesstif { };
* Added FreeGLUT. svn path=/nixpkgs/trunk/; revision=8592
2007-04-18 14:47:35 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lesstif93 = callPackage ../development/libraries/lesstif-0.93 { };
Added older version of lesstif for arb svn path=/nixpkgs/trunk/; revision=12974
2008-10-06 16:11:36 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
levmar = callPackage ../development/libraries/levmar { };
Updating meshlab. Their build system has changed, and the source tree they distribute too, so the dependencies changed a bit. To get meshlab working, I update lib3ds and add levmar. svn path=/nixpkgs/trunk/; revision=19595
2010-01-21 14:39:53 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lib3ds = callPackage ../development/libraries/lib3ds { };
added freestyle (non photorealistic renderer) and dependencies libQGLViewer, lib3ds svn path=/nixpkgs/trunk/; revision=12009
2008-06-08 04:56:32 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libaal = callPackage ../development/libraries/libaal { };
* Reiser4 stuff. svn path=/nixpkgs/trunk/; revision=10498
2008-02-04 14:37:15 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
libao = callPackage ../development/libraries/libao {
Making pulseaudio optional on libao. svn path=/nixpkgs/trunk/; revision=20018
2010-02-15 17:10:35 +00:00
usePulseAudio = getConfig [ "pulseaudio" ] true;
Add mpg321, libao and libid3tag; upgrade libmad. svn path=/nixpkgs/trunk/; revision=10626
2008-02-11 21:02:38 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libarchive = callPackage ../development/libraries/libarchive { };
libarchive added svn path=/nixpkgs/trunk/; revision=10349
2008-01-28 19:46:38 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libassuan1 = callPackage ../development/libraries/libassuan1 { };
Add libassuan1 back opensc needs it svn path=/nixpkgs/trunk/; revision=21887
2010-05-19 21:59:15 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libassuan = callPackage ../development/libraries/libassuan { };
libassuan added svn path=/nixpkgs/trunk/; revision=10341
2008-01-28 19:43:37 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libavc1394 = callPackage ../development/libraries/libavc1394 { };
kino (compiling but neither finding libX11 nor libghtread) and libiec61883 (dependency) added svn path=/nixpkgs/trunk/; revision=10133
2008-01-13 15:21:21 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libcaca = callPackage ../development/libraries/libcaca { };
added cil-aterm to nixpkgs svn path=/nixpkgs/trunk/; revision=4482
2006-01-02 14:24:36 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
libcanberra = callPackage ../development/libraries/libcanberra {
libcanberra: Fix dependencies. svn path=/nixpkgs/branches/stdenv-updates/; revision=15088
2009-04-16 15:23:38 +01:00
inherit (gtkLibs) gtk gthread;
Add `libcanberra'. svn path=/nixpkgs/trunk/; revision=13814
2009-01-20 09:50:15 +00:00
gstreamer = gst_all.gstreamer;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libcdaudio = callPackage ../development/libraries/libcdaudio { };
* Converting packages. This is the minimal Nix stdenv for building the ATerm library. svn path=/nixpkgs/trunk/; revision=459
2003-11-02 17:42:19 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libcddb = callPackage ../development/libraries/libcddb { };
Add libcddb and GNU libcdio. svn path=/nixpkgs/trunk/; revision=10960
2008-03-05 09:10:23 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libcdio = callPackage ../development/libraries/libcdio { };
Add libcddb and GNU libcdio. svn path=/nixpkgs/trunk/; revision=10960
2008-03-05 09:10:23 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
libchamplain = callPackage ../development/libraries/libchamplain {
Add libchamplain, a library to display maps. svn path=/nixpkgs/trunk/; revision=22649
2010-07-18 23:46:19 +01:00
inherit (gnome) gtk glib libsoup;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libcm = callPackage ../development/libraries/libcm { };
geos library added svn path=/nixpkgs/trunk/; revision=9837
2007-12-03 16:01:51 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libcue = callPackage ../development/libraries/libcue { };
libcue: New nixpkg. svn path=/nixpkgs/trunk/; revision=21147
2010-04-18 20:12:07 +01:00
Added qrencode and qrdecode - tools for QR code. Qrdecode behaves strangely (Debian package does the same, so probably upstream bug) svn path=/nixpkgs/trunk/; revision=13304
2008-11-15 17:54:09 +00:00
libcv = builderDefsPackage (import ../development/libraries/libcv) {
inherit libtiff libjpeg libpng pkgconfig;
inherit (gtkLibs) gtk 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 17:26:58 +01:00
libdaemon = callPackage ../development/libraries/libdaemon { };
Added support for overridable variants of package. For details read comments near getVersion function, gettext is the current example. svn path=/nixpkgs/trunk/; revision=9235
2007-09-01 19:26:13 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libdbi = callPackage ../development/libraries/libdbi { };
add Google's coredumper helper library (snapshots/coredumps for running programs) svn path=/nixpkgs/trunk/; revision=5485
2006-06-21 22:05:39 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
libdbiDriversBase = callPackage ../development/libraries/libdbi-drivers {
* ltrace: updated to 0.5.3. * libdbi / libdbi-drivers: updated to 0.8.3, and make it compile with SQLite. * qemu-image: fix the URL. * gdmap: make it build again (requires an older GTK+). * rlwrap: updated to 0.37. * smbfs-fuse -> fusesmb to match the upstream name. * x11vnc: updated to 0.9.10. * clearlyU: fix the URL. * Various packages: follow the coding conventions. svn path=/nixpkgs/trunk/; revision=22814
2010-07-29 19:55:16 +01:00
mysql = null;
sqlite = null;
* Removed selectVersion. There's no good reason to write `selectVersion ./foo "bar"' instead of `import ./foo/bar.nix'. * Replaced `with args' with formal function arguments in several packages. * Renamed several files to `default.nix'. As a general rule, version numbers should only be included in the filename when there is a reason to keep multiple versions of a package in Nixpkgs. Otherwise, it just makes it harder to update the package. svn path=/nixpkgs/trunk/; revision=18403
2009-11-18 09:39:59 +00:00
};
gdal library added svn path=/nixpkgs/trunk/; revision=9246
2007-09-04 10:38:52 +01:00
* composedArgsAndFun -> makeOverridable for consistency. * Rename a few single-version packages to "default.nix". svn path=/nixpkgs/trunk/; revision=22803
2010-07-29 09:21:21 +01:00
libdbiDrivers = libdbiDriversBase.override {
MySQL5 should be default already. svn path=/nixpkgs/branches/stdenv-updates-merge/; revision=10846
2008-02-25 03:16:07 +00:00
inherit sqlite mysql;
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
* Stdenv for Linux, i.e., with a Nix-built glibc. svn path=/nixpkgs/trunk/; revision=461
2003-11-02 22:25:26 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libdv = callPackage ../development/libraries/libdv { };
Added glibc-ntpl to all-packages.nix . I also do not know if it works. svn path=/nixpkgs/trunk/; revision=9158
2007-08-18 17:20:14 +01:00
pkgs/top-level/all-packages.nix: disable libdrm on Darwin platforms libdrm doesn't build on Darwin and, according to the Xorg developers, isn't supposed to be built. This change fixes the build of haskell-platform-ghc6.12.2-2010.1.0.0 on Darwin. svn path=/nixpkgs/trunk/; revision=21432
2010-04-29 15:57:23 +01:00
libdrm = if stdenv.isDarwin then null else (import ../development/libraries/libdrm {
* X.org 7.5. svn path=/nixpkgs/branches/xorg-7.5/; revision=18034
2009-10-29 17:56:10 +00:00
inherit fetchurl stdenv pkgconfig;
inherit (xorg) libpthreadstubs;
pkgs/top-level/all-packages.nix: disable libdrm on Darwin platforms libdrm doesn't build on Darwin and, according to the Xorg developers, isn't supposed to be built. This change fixes the build of haskell-platform-ghc6.12.2-2010.1.0.0 on Darwin. svn path=/nixpkgs/trunk/; revision=21432
2010-04-29 15:57:23 +01:00
});
* Stdenv for Linux, i.e., with a Nix-built glibc. svn path=/nixpkgs/trunk/; revision=461
2003-11-02 22:25:26 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libdvdcss = callPackage ../development/libraries/libdvdcss { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libdvdnav = callPackage ../development/libraries/libdvdnav { };
* Added wxHaskell. * Added GNU MP, use it in pycrypto. svn path=/nixpkgs/trunk/; revision=7343
2006-12-13 22:29:40 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libdvdread = callPackage ../development/libraries/libdvdread { };
Added Falling Sand Game and wxGTK without unicode for it. svn path=/nixpkgs/trunk/; revision=9543
2007-10-27 18:55:13 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libedit = callPackage ../development/libraries/libedit { };
* editline: renamed to libedit (which seems to be the proper name for the package). * Removed the old ghc-wrapper, which hasn't been used for a long time. * Renamed the "boot" GHC to "binary", which is more descriptive. (They *can* be used for other things than bootstrapping a GHC source build.) * Updated the GHC 6.10.1 binary to 6.10.2. svn path=/nixpkgs/trunk/; revision=15095
2009-04-16 20:25:22 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libelf = callPackage ../development/libraries/libelf { };
Add libelf. svn path=/nixpkgs/trunk/; revision=21400
2010-04-28 13:36:58 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
liblo = callPackage ../development/libraries/liblo { };
adding liblo svn path=/nixpkgs/trunk/; revision=17322
2009-09-21 10:58:27 +01:00
Adding libev - an even loop library remotely similar to libevent svn path=/nixpkgs/trunk/; revision=16877
2009-08-27 08:17:57 +01: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 17:26:58 +01:00
libevent = callPackage ../development/libraries/libevent { };
Added sglr svn path=/nixpkgs/trunk/; revision=707
2004-01-22 19:09:49 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libewf = callPackage ../development/libraries/libewf { };
Adding libewf. svn path=/nixpkgs/trunk/; revision=15225
2009-04-21 20:47:41 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libexif = callPackage ../development/libraries/libexif { };
* Build ssmtp with TLS support. * Added gnutls (but it turns out that ssmtp also builds with openssl, so I don't actually use it). svn path=/nixpkgs/trunk/; revision=9604
2007-11-08 17:48:52 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
libextractor = callPackage ../development/libraries/libextractor {
GNU libextractor 0.5.23. svn path=/nixpkgs/trunk/; revision=19216
2010-01-05 11:16:30 +00:00
inherit (gnome) gtk;
libmpeg2 = mpeg2dec;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
Added jikespg, an oldskool parser generator svn path=/nixpkgs/trunk/; revision=5038
2006-03-14 18:20:21 +00:00
Updating CLisp and adding SBCL. SBCL currently has to be symlinked to a writable directory (I am investigating a fix). CLisp 2.47 is somewhat incompatible with lots of software, so I added 2.44.1 as preserved version svn path=/nixpkgs/trunk/; revision=15806
2009-05-31 07:07:25 +01: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 17:26:58 +01:00
libffi = callPackage ../development/libraries/libffi { };
Add libffi, a foreign function interface library. svn path=/nixpkgs/trunk/; revision=11505
2008-04-09 08:40:48 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libftdi = callPackage ../development/libraries/libftdi { };
Made openocd work with ft2232 jtag chipset, that of the Sheevaplug. svn path=/nixpkgs/trunk/; revision=17407
2009-09-24 22:28:27 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libgcrypt = callPackage ../development/libraries/libgcrypt { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libgpgerror = callPackage ../development/libraries/libgpg-error { };
* Converted some more packages. * Subversion no longer needs libxml2 (just expat). svn path=/nixpkgs/trunk/; revision=478
2003-11-05 12:17:48 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libgphoto2 = callPackage ../development/libraries/libgphoto2 { };
libcdaudio 0.99.12 svn path=/nixpkgs/trunk/; revision=2062
2005-01-19 21:12:46 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libgpod = callPackage ../development/libraries/libgpod { };
Adding libgpod, for a future gtkpod. svn path=/nixpkgs/trunk/; revision=15015
2009-04-13 16:41:00 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libharu = callPackage ../development/libraries/libharu { };
adding haru pdf lib svn path=/nixpkgs/trunk/; revision=17076
2009-09-13 09:54:44 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libical = callPackage ../development/libraries/libical { };
Use $NIXPKGS_CONFIG to determine whether ghostscript has cups support. svn path=/nixpkgs/trunk/; revision=14275
2009-02-27 13:44:31 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
libiodbc = callPackage ../development/libraries/libiodbc {
* libiodbc: don't pass all of Nixpkgs to the package. There is no reason why this shouldn't work, but it breaks NixOS evaluation on x86_64-linux with weird segfaults and assertion failures, probably due to a bug in the evaluator or the ATerm library. svn path=/nixpkgs/trunk/; revision=20953
2010-04-06 11:50:52 +01:00
inherit (gtkLibs) gtk;
useGTK = getPkgConfig "libiodbc" "gtk" false;
};
Add libiodbc Use experimental style. Will revert to "standard" one if needed. svn path=/nixpkgs/trunk/; revision=20929
2010-04-03 10:53:38 +01:00
Add libktorrent svn path=/nixpkgs/trunk/; revision=23186
2010-08-16 09:34:26 +01:00
libktorrent = newScope kde45 ../development/libraries/libktorrent { };
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
liblqr1 = callPackage ../development/libraries/liblqr-1 {
Add liblqr-1 svn path=/nixpkgs/trunk/; revision=21559
2010-05-03 04:45:47 +01:00
inherit (gnome) glib;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
libnice = callPackage ../development/libraries/libnice {
add libnice svn path=/nixpkgs/trunk/; revision=19134
2009-12-27 14:22:00 +00: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 17:26:58 +01:00
libQGLViewer = callPackage ../development/libraries/libqglviewer { };
added freestyle (non photorealistic renderer) and dependencies libQGLViewer, lib3ds svn path=/nixpkgs/trunk/; revision=12009
2008-06-08 04:56:32 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libsamplerate = callPackage ../development/libraries/libsamplerate { };
added libvorbis libogg and flac svn path=/nixpkgs/trunk/; revision=2063
2005-01-19 21:48:45 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
libspectre = callPackage ../development/libraries/libspectre {
Libspectre 0.2.0, a PostScript rendering library. svn path=/nixpkgs/trunk/; revision=12375
2008-07-17 20:43:11 +01:00
ghostscript = ghostscriptX;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
libgsf = callPackage ../development/libraries/libgsf {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gnome) glib gnomevfs libbonobo;
};
added libvorbis libogg and flac svn path=/nixpkgs/trunk/; revision=2063
2005-01-19 21:48:45 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libiconv = callPackage ../development/libraries/libiconv { };
Add GNU libiconv as a stand-alone package. svn path=/nixpkgs/trunk/; revision=17282
2009-09-19 23:03:24 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libid3tag = callPackage ../development/libraries/libid3tag { };
Add mpg321, libao and libid3tag; upgrade libmad. svn path=/nixpkgs/trunk/; revision=10626
2008-02-11 21:02:38 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libidn = callPackage ../development/libraries/libidn { };
enable usbutils and libusb svn path=/nixpkgs/trunk/; revision=4507
2006-01-07 17:25:39 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libiec61883 = callPackage ../development/libraries/libiec61883 { };
kino (compiling but neither finding libX11 nor libghtread) and libiec61883 (dependency) added svn path=/nixpkgs/trunk/; revision=10133
2008-01-13 15:21:21 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
libinfinity = callPackage ../development/libraries/libinfinity {
Packaged libinfinity svn path=/nixpkgs/trunk/; revision=22359
2010-06-21 17:06:18 +01:00
inherit (gtkLibs) gtk glib;
inherit (gnome) gtkdoc;
};
pkgs/top-level/all-packages.nix: stripped trailing whitespace svn path=/nixpkgs/trunk/; revision=22734
2010-07-26 14:41:09 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libiptcdata = callPackage ../development/libraries/libiptcdata { };
Adding libiptcdata. I'm attempting to build rawtherapee, but it wants the propietary library 'rawzor'. Maybe upstream someone will allow building without it some day. Until then, no rawtherapee. svn path=/nixpkgs/trunk/; revision=19497
2010-01-17 00:46:57 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libjingle = callPackage ../development/libraries/libjingle/0.3.11.nix { };
* Merged most of the stdenv-updates branch. Some stuff didn't merge cleanly right away (kde-4, kernel stuff) so it should be merged later. But the stdenv stuff is all there. svn path=/nixpkgs/branches/stdenv-updates-merge/; revision=10793
2008-02-20 23:02:41 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libjpeg = callPackage ../development/libraries/libjpeg { };
add speex, without Ogg support (if anyone wants that, just add it) svn path=/nixpkgs/trunk/; revision=4308
2005-11-22 22:32:18 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libjpeg_turbo = callPackage ../development/libraries/libjpeg-turbo { };
Adding virtualgl (and therefore, libjpeg-turbo, a SIMD API-compatible libjpeg) svn path=/nixpkgs/trunk/; revision=22553
2010-07-10 09:45:44 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
libjpeg62 = callPackage ../development/libraries/libjpeg/62.nix {
re-added libjpeg62 for chrome, updated chrome svn path=/nixpkgs/trunk/; revision=19199
2010-01-04 07:47:32 +00:00
libtool = libtool_1_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 17:26:58 +01:00
libksba = callPackage ../development/libraries/libksba { };
Added libksba svn path=/nixpkgs/trunk/; revision=10342
2008-01-28 19:44:20 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libmad = callPackage ../development/libraries/libmad { };
- add a whole bunch of packages which were added today already (but also list them here) - enable OOo2 build svn path=/nixpkgs/trunk/; revision=4149
2005-10-26 22:10:31 +01:00
Adding the matchbox window manager svn path=/nixpkgs/trunk/; revision=23076
2010-08-09 23:40:51 +01: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 17:26:58 +01:00
libmatthew_java = callPackage ../development/libraries/java/libmatthew-java { };
Added dbus-java and libmatthew-java (dependency for dbus-java) packages svn path=/nixpkgs/trunk/; revision=19170
2010-01-02 13:28:51 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libmcs = callPackage ../development/libraries/libmcs { };
* Added Audacious, a fork of beep-media-player (which doesn't seem to work very well after the Glibc update), plus its dependencies. TODO: make an audacious-wrapper that lets Audacious find its plugins automatically. Currently you have to install audacious-plugins and symlink ~/.nix-profile/lib/audacious/* in ~/.local/share/audacious/Plugins. svn path=/nixpkgs/trunk/; revision=10927
2008-03-03 10:55:20 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libmicrohttpd = callPackage ../development/libraries/libmicrohttpd { };
add libmicrohttpd svn path=/nixpkgs/trunk/; revision=11813
2008-05-11 12:46:48 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libmikmod = callPackage ../development/libraries/libmikmod { };
libmikmod: New nixpkg. svn path=/nixpkgs/trunk/; revision=21146
2010-04-18 19:57:35 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libmilter = callPackage ../development/libraries/libmilter { };
added libmilter, opendkim svn path=/nixpkgs/trunk/; revision=19875
2010-02-09 10:32:55 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libmowgli = callPackage ../development/libraries/libmowgli { };
* Added Audacious, a fork of beep-media-player (which doesn't seem to work very well after the Glibc update), plus its dependencies. TODO: make an audacious-wrapper that lets Audacious find its plugins automatically. Currently you have to install audacious-plugins and symlink ~/.nix-profile/lib/audacious/* in ~/.local/share/audacious/Plugins. svn path=/nixpkgs/trunk/; revision=10927
2008-03-03 10:55:20 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libmng = callPackage ../development/libraries/libmng { };
adding libmng svn path=/nixpkgs/trunk/; revision=17075
2009-09-13 09:54:41 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libmpcdec = callPackage ../development/libraries/libmpcdec { };
- add a whole bunch of packages which were added today already (but also list them here) - enable OOo2 build svn path=/nixpkgs/trunk/; revision=4149
2005-10-26 22:10:31 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libmsn = callPackage ../development/libraries/libmsn { };
Use $NIXPKGS_CONFIG to determine whether ghostscript has cups support. svn path=/nixpkgs/trunk/; revision=14275
2009-02-27 13:44:31 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libmspack = callPackage ../development/libraries/libmspack { };
* Converted more packages. svn path=/nixpkgs/trunk/; revision=488
2003-11-06 15:24:19 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libmusclecard = callPackage ../development/libraries/libmusclecard { };
Adding more muscle programs and libraries. svn path=/nixpkgs/trunk/; revision=19320
2010-01-09 18:06:37 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libnih = callPackage ../development/libraries/libnih { };
* Upstart updated to 0.6.5. * Added libnih (a dependency of Upstart). * Removed the old Upstart 0.3.x. svn path=/nixpkgs/trunk/; revision=20015
2010-02-15 15:55:39 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libnova = callPackage ../development/libraries/libnova { };
libnova added svn path=/nixpkgs/trunk/; revision=10351
2008-01-28 19:47:12 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libofx = callPackage ../development/libraries/libofx { };
Adding libofx and updating opensp (to get libofx built). (I may have broken openjade... I will check later). svn path=/nixpkgs/trunk/; revision=19697
2010-01-26 22:04:54 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libogg = callPackage ../development/libraries/libogg { };
* Use all those new packages. svn path=/nixpkgs/trunk/; revision=545
2003-11-25 18:02:05 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
liboil = callPackage ../development/libraries/liboil { };
- svn path=/nixpkgs/branches/stdenv-updates-merge/; revision=10823
2008-02-22 03:06:12 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
liboop = callPackage ../development/libraries/liboop { };
Add GNU lsh, a GPL'd implementation of SSH, and `liboop', and event loop library. svn path=/nixpkgs/trunk/; revision=10637
2008-02-12 10:51:44 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libotr = callPackage ../development/libraries/libotr { };
Added aspell Added gtkspell Added pidgin, builds but does not run yet: running pidgin fails to find libX11.so.6. ldd on pidgin reports: libX11.so.6 => not found .... libX11.so.6 => /nix/store/brsva6rh1p2ymjvk7054a90is5panrhf-libX11-1.1.1/lib/libX11.so.6 (0xb7358000) which looks a bit weird ... Maybe some problem with patchelf? Or just a build problem and should the library path be set using an environment variable? svn path=/nixpkgs/trunk/; revision=8660
2007-05-13 15:22:24 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libp11 = callPackage ../development/libraries/libp11 { };
Adding engine_pkcs11, a openssl engine for pkcs11 implementations for smartcards. svn path=/nixpkgs/trunk/; revision=19324
2010-01-09 22:22:41 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libpcap = callPackage ../development/libraries/libpcap { };
Added hsqldb to all-packages svn path=/nixpkgs/trunk/; revision=9265
2007-09-06 16:56:39 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libpng = callPackage ../development/libraries/libpng { };
Some upgrades needed for kde4: * alsa-lib: 1.0.12 -> 1.0.14 * alsa-utils: 1.0.13 -> 1.0.14 * strigi: 0.5.1 -> 0.5.3dev * libgpg-error: 1.0 -> 1.4 * gpgme: 1.0.3 -> 1.1.4 * cmake: 2.4.6 -> 2.4.7 * Some kde4 components added (not compilable yet). * icu4c-3.6 added * boost: added unicode support to RegEx, switched to "system" layout svn path=/nixpkgs/trunk/; revision=9068
2007-08-08 14:20:18 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libproxy = callPackage ../development/libraries/libproxy { };
Temporarily disable gimpPlugins to remedy the following failure when calling nix-env: error: undefined variable `gtkLibs', in `nix-pkgs-current/pkgs/applications/graphics/gimp/plugins/default.nix' svn path=/nixpkgs/trunk/; revision=16041
2009-06-25 14:37:59 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libpseudo = callPackage ../development/libraries/libpseudo { };
Adding vwm, the console window manager. svn path=/nixpkgs/trunk/; revision=15255
2009-04-22 22:33:24 +01:00
Add libqalculate svn path=/nixpkgs/trunk/; revision=23180
2010-08-15 14:55:02 +01:00
libqalculate = callPackage ../development/libraries/libqalculate { };
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
librsync = callPackage ../development/libraries/librsync { };
Adding 'duplicity', and its dependency 'librsync' svn path=/nixpkgs/trunk/; revision=19813
2010-02-04 13:42:41 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libsigcxx = callPackage ../development/libraries/libsigcxx { };
* Converted some more packages. * Subversion no longer needs libxml2 (just expat). svn path=/nixpkgs/trunk/; revision=478
2003-11-05 12:17:48 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libsigsegv = callPackage ../development/libraries/libsigsegv { };
* Added feh to set the root image. * Compiz extra plugins. svn path=/nixpkgs/trunk/; revision=8178
2007-03-05 13:44:27 +00:00
Restore libsigsegv-2.5 and fix clisp-2.44.1 build for bootstrapping needs svn path=/nixpkgs/trunk/; revision=16632
2009-08-10 06:20:14 +01: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 17:26:58 +01:00
libsigsegv_25 = callPackage ../development/libraries/libsigsegv/2.5.nix { };
Restore libsigsegv-2.5 and fix clisp-2.44.1 build for bootstrapping needs svn path=/nixpkgs/trunk/; revision=16632
2009-08-10 06:20:14 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libsndfile = callPackage ../development/libraries/libsndfile { };
Added Compiz Fusion (main plugins). Also some dependencies, and made wmii build under setup-new-2.sh also. svn path=/nixpkgs/trunk/; revision=9577
2007-11-05 08:32:20 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libssh = callPackage ../development/libraries/libssh { };
Adding 'awesome' (and two packages it was depending on) svn path=/nixpkgs/trunk/; revision=20385
2010-03-04 14:44:56 +00:00
Add libssh2 svn path=/nixpkgs/trunk/; revision=22975
2010-08-05 21:24:32 +01: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 17:26:58 +01:00
libstartup_notification = callPackage ../development/libraries/startup-notification { };
pkgs/applications/editors/emacs-modes/magit: updated to version magit-0.7-94-gbf42bf8 Magit has seen plenty of development since version 0.7, but for some reason there haven't been any new releases. This version bump updates the expression to build a current version of Magit directly from the Git repository. This change adds buildInputs 'autoconf' and 'automake'. These tools are required only because we aren't building from a proper release tarball. Once version 0.8 comes out, these dependencies can be dropped again. svn path=/nixpkgs/trunk/; revision=20650
2010-03-16 12:13:40 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libtasn1 = callPackage ../development/libraries/libtasn1 { };
* Gnome 2.22.1. * Moved some of the Gnome package Nix expressions into pkgs/desktops/gnome/default.nix - no need to have them in separate files. This way the code is much shorter. Still to be done for all the other Gnome packages. * Glib 2.16.3. svn path=/nixpkgs/branches/stdenv-updates/; revision=11855
2008-05-20 15:25:09 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libtheora = callPackage ../development/libraries/libtheora { };
Added Compiz Fusion (main plugins). Also some dependencies, and made wmii build under setup-new-2.sh also. svn path=/nixpkgs/trunk/; revision=9577
2007-11-05 08:32:20 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libtiff = callPackage ../development/libraries/libtiff { };
* add unison - unison uses a wrapper script to add font-schumacher-misc to the local X font path if the font isn't already present; this is necessary for it to work, but not terribly nice ... * lablgtk is a dependency of unison - handling of library dirs with ocaml is a hack so far; in principle, ocaml needs a general setup for library dirs like ghc svn path=/nixpkgs/trunk/; revision=9094
2007-08-10 09:21:31 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libtommath = callPackage ../development/libraries/libtommath { };
* Added convertlit, a tool for converting Microsoft Reader ebooks, plus its dependency libtommath. svn path=/nixpkgs/trunk/; revision=12606
2008-08-12 20:57:35 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libgeotiff = callPackage ../development/libraries/libgeotiff { };
Add GNU Libunistring, a Unicode string handling library. svn path=/nixpkgs/trunk/; revision=16071
2009-06-27 22:44:47 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libunistring = callPackage ../development/libraries/libunistring { };
Add libupnp, a UPnP implementation. svn path=/nixpkgs/trunk/; revision=12995
2008-10-07 22:18:01 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libupnp = callPackage ../development/libraries/pupnp { };
move libungif svn path=/nixpkgs/trunk/; revision=10026
2007-12-31 21:52:43 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
giflib = callPackage ../development/libraries/giflib { };
* Converted more packages. svn path=/nixpkgs/trunk/; revision=488
2003-11-06 15:24:19 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libungif = callPackage ../development/libraries/giflib/libungif.nix { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libusb = callPackage ../development/libraries/libusb { };
libunwind added svn path=/nixpkgs/trunk/; revision=10345
2008-01-28 19:45:30 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libunwind = callPackage ../development/libraries/libunwind { };
Added libv4l which is now a required dependency for kdenetwork-4.4.1 svn path=/nixpkgs/trunk/; revision=20349
2010-03-03 10:37:38 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libv4l = callPackage ../development/libraries/libv4l { };
libvirt = callPackage ../development/libraries/libvirt { };
applying patches provided by griswold svn path=/nixpkgs/trunk/; revision=19707
2010-01-27 12:12:35 +00:00
Some of preparation work for adding Xen. Troubles: 1. Xen Dom0 support not complete in mainline. 2. Xen's love to check for headers in /usr/include. To do afterwards: We need to change bootloading setup a bit. svn path=/nixpkgs/trunk/; revision=12941
2008-10-04 16:24:08 +01:00
libvncserver = builderDefsPackage (import ../development/libraries/libvncserver) {
inherit libtool libjpeg openssl zlib;
maudeUnstable: updated full-maude to latest alpha release svn path=/nixpkgs/trunk/; revision=13017
2008-10-09 11:10:49 +01:00
inherit (xlibs) xproto libX11 damageproto libXdamage
Some of preparation work for adding Xen. Troubles: 1. Xen Dom0 support not complete in mainline. 2. Xen's love to check for headers in /usr/include. To do afterwards: We need to change bootloading setup a bit. svn path=/nixpkgs/trunk/; revision=12941
2008-10-04 16:24:08 +01: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 17:26:58 +01:00
libviper = callPackage ../development/libraries/libviper { };
Adding vwm, the console window manager. svn path=/nixpkgs/trunk/; revision=15255
2009-04-22 22:33:24 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libvpx = callPackage ../development/libraries/libvpx { };
Adding libvpx (the codec VP8). Still no package uses it. svn path=/nixpkgs/trunk/; revision=21958
2010-05-24 22:57:45 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libvterm = callPackage ../development/libraries/libvterm { };
Updating vwm and its libraries. svn path=/nixpkgs/trunk/; revision=18123
2009-11-04 22:38:26 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libvorbis = callPackage ../development/libraries/libvorbis { };
add fribidi and abiword commit 5666 + 1! svn path=/nixpkgs/trunk/; revision=5667
2006-07-08 13:44:39 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libwmf = callPackage ../development/libraries/libwmf { };
* Converted more packages. svn path=/nixpkgs/trunk/; revision=488
2003-11-06 15:24:19 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
libwpd = callPackage ../development/libraries/libwpd {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gnome) glib;
};
* Build metacity with compositing support. svn path=/nixpkgs/trunk/; revision=8114
2007-02-28 17:52:41 +00:00
Adding vbetool svn path=/nixpkgs/trunk/; revision=17952
2009-10-24 20:58:07 +01: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 17:26:58 +01:00
libxcrypt = callPackage ../development/libraries/libxcrypt { };
* ifplugd: program for monitoring the link status of ethernet interfaces. * libdaemon: dependency of ifplugd. svn path=/nixpkgs/trunk/; revision=9061
2007-08-06 19:45:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libxdg_basedir = callPackage ../development/libraries/libxdg-basedir { };
Adding 'awesome' (and two packages it was depending on) svn path=/nixpkgs/trunk/; revision=20385
2010-03-04 14:44:56 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libxklavier = callPackage ../development/libraries/libxklavier { };
libxklavier added svn path=/nixpkgs/branches/stdenv-updates/; revision=10749
2008-02-18 20:53:36 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libxmi = callPackage ../development/libraries/libxmi { };
Adding enblend-fuse, libxmi and hugin. Maybe hugin doesn't run well enough still. svn path=/nixpkgs/trunk/; revision=14894
2009-04-05 22:41:38 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
libxml2 = callPackage ../development/libraries/libxml2 {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
pythonSupport = false;
};
Added gdmap, changed builder-defs to use derivation attribute on propagatedBuildInputs, manually fixed Xorg expression problem for Compiz, various fixes. svn path=/nixpkgs/trunk/; revision=9812
2007-12-01 16:20:23 +00:00
* Disable some Haskell packages on Darwin. svn path=/nixpkgs/branches/stdenv-updates/; revision=15270
2009-04-23 13:33:09 +01:00
libxml2Python = libxml2.override {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
pythonSupport = true;
* Disable some Haskell packages on Darwin. svn path=/nixpkgs/branches/stdenv-updates/; revision=15270
2009-04-23 13:33:09 +01:00
};
Added gdmap, changed builder-defs to use derivation attribute on propagatedBuildInputs, manually fixed Xorg expression problem for Compiz, various fixes. svn path=/nixpkgs/trunk/; revision=9812
2007-12-01 16:20:23 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
libxmlxx = callPackage ../development/libraries/libxmlxx {
Packaged libxml++ svn path=/nixpkgs/trunk/; revision=22417
2010-06-26 02:40:42 +01: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 17:26:58 +01:00
libxslt = callPackage ../development/libraries/libxslt { };
Added gdmap, changed builder-defs to use derivation attribute on propagatedBuildInputs, manually fixed Xorg expression problem for Compiz, various fixes. svn path=/nixpkgs/trunk/; revision=9812
2007-12-01 16:20:23 +00:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
libixp_for_wmii = lowPrio (import ../development/libraries/libixp_for_wmii {
inherit fetchurl stdenv;
});
Added gdmap, changed builder-defs to use derivation attribute on propagatedBuildInputs, manually fixed Xorg expression problem for Compiz, various fixes. svn path=/nixpkgs/trunk/; revision=9812
2007-12-01 16:20:23 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libyaml = callPackage ../development/libraries/libyaml { };
Add libyaml and PyYAML. svn path=/nixpkgs/trunk/; revision=19477
2010-01-16 10:37:29 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libzip = callPackage ../development/libraries/libzip { };
add zlibStatic svn path=/nixpkgs/trunk/; revision=5933
2006-07-25 09:44:05 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libzrtpcpp = callPackage ../development/libraries/libzrtpcpp { };
adding twinkle, a voice over IP phone software svn path=/nixpkgs/trunk/; revision=17303
2009-09-20 18:01:19 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lightning = callPackage ../development/libraries/lightning { };
Add GNU lightning, a run-time code generation library. svn path=/nixpkgs/trunk/; revision=12237
2008-07-01 15:47:49 +01:00
Adding liquidwar6 svn path=/nixpkgs/trunk/; revision=18996
2009-12-16 16:06:30 +00:00
liquidwar = builderDefsPackage ../games/liquidwar {
inherit (xlibs) xproto libX11 libXrender;
pkgs/top-level/all-packages.nix: switch to Python 2.6 (except on Darwin) MacOS X can build Python 2.6 just fine, but for some reason a lot of modules don't work, so the resulting binary isn't very useful. svn path=/nixpkgs/branches/stdenv-updates/; revision=19598
2010-01-21 15:39:11 +00:00
inherit gmp guile mesa libjpeg libpng
Adding liquidwar6 svn path=/nixpkgs/trunk/; revision=18996
2009-12-16 16:06:30 +00:00
expat gettext perl
SDL SDL_image SDL_mixer SDL_ttf
curl sqlite
libogg libvorbis
;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
log4cxx = callPackage ../development/libraries/log4cxx { };
* Converted more packages. svn path=/nixpkgs/trunk/; revision=488
2003-11-06 15:24:19 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
loudmouth = callPackage ../development/libraries/loudmouth { };
loudmouth library added svn path=/nixpkgs/trunk/; revision=10359
2008-01-28 19:49:25 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lzo = callPackage ../development/libraries/lzo { };
* Converted more packages. svn path=/nixpkgs/trunk/; revision=488
2003-11-06 15:24:19 +00:00
* Added Audacious, a fork of beep-media-player (which doesn't seem to work very well after the Glibc update), plus its dependencies. TODO: make an audacious-wrapper that lets Audacious find its plugins automatically. Currently you have to install audacious-plugins and symlink ~/.nix-profile/lib/audacious/* in ~/.local/share/audacious/Plugins. svn path=/nixpkgs/trunk/; revision=10927
2008-03-03 10:55:20 +00: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 17:26:58 +01:00
mediastreamer = callPackage ../development/libraries/mediastreamer { };
alsaUtils = alsa.alsaUtils added: services need this svn path=/nixpkgs/branches/stdenv-updates/; revision=10535
2008-02-07 09:43:10 +00:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
mesaSupported =
system == "i686-linux" ||
Specify some obvious platform sets svn path=/nixpkgs/trunk/; revision=17205
2009-09-16 16:12:24 +01:00
system == "x86_64-linux" ||
some more x86_64 darwin changes svn path=/nixpkgs/trunk/; revision=18774
2009-12-02 22:19:49 +00:00
system == "x86_64-darwin" ||
Specify some obvious platform sets svn path=/nixpkgs/trunk/; revision=17205
2009-09-16 16:12:24 +01:00
system == "i686-darwin";
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
mesa = callPackage ../development/libraries/mesa {
pkgs/development/libraries/mesa: pass lipo utility to this build on Darwin svn path=/nixpkgs/trunk/; revision=21427
2010-04-29 15:56:52 +01:00
lipo = if stdenv.isDarwin then darwinLipoUtility else null;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
* Converted more packages. svn path=/nixpkgs/trunk/; revision=488
2003-11-06 15:24:19 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ming = callPackage ../development/libraries/ming { };
Add Ming, a C library to generate Flash files. svn path=/nixpkgs/trunk/; revision=12786
2008-09-02 14:43:53 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
mlt = callPackage ../development/libraries/mlt {
Adding kdenlive, and as a side effect, mlt. Kdenlive looks for some binaries in PATH, so some dependencies may be fulfilled not by kdenlive nix expression. svn path=/nixpkgs/trunk/; revision=21458
2010-04-30 14:12:07 +01:00
qt = qt4;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mpeg2dec = callPackage ../development/libraries/mpeg2dec { };
Tried to add kuickshow (a pretty fast image viewer that used to be distributed by default in KDE). Unfortunately it doesn't work, because of some strange problems with mime types. But well, it compiles. The libraries are useful anyway: - arts (kde) - imlib (gnome) - libungif (aka libgif) svn path=/nixpkgs/trunk/; revision=6111
2006-08-13 10:46:54 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
msilbc = callPackage ../development/libraries/msilbc { };
ilbc and msilbc libraries added svn path=/nixpkgs/branches/stdenv-updates/; revision=10570
2008-02-10 17:35:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mpc = callPackage ../development/libraries/mpc { };
Add MPC. svn path=/nixpkgs/trunk/; revision=21399
2010-04-28 13:36:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mpich2 = callPackage ../development/libraries/mpich2 { };
Add MPICH2, an implementation of the Message Passing Interface. svn path=/nixpkgs/trunk/; revision=10807
2008-02-21 16:17:43 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
muparser = callPackage ../development/libraries/muparser { };
Adding muparser and meshlab. svn path=/nixpkgs/trunk/; revision=15585
2009-05-13 11:21:29 +01:00
* composedArgsAndFun -> makeOverridable for consistency. * Rename a few single-version packages to "default.nix". svn path=/nixpkgs/trunk/; revision=22803
2010-07-29 09:21:21 +01:00
ncurses = makeOverridable (import ../development/libraries/ncurses) {
Fixing a trivial error in the glibc-2.11 longDescription, and fixing the arguments for the ncurses expression. We should find a way to express a dependency in cross compilation of the style "cross-ncurses depends on having the native-ncurses". svn path=/nixpkgs/branches/stdenv-updates/; revision=18479
2009-11-20 08:27:59 +00:00
inherit fetchurl stdenv;
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-17 22:58:48 +00:00
# The "! (stdenv ? cross)" is for the cross-built arm ncurses, which
# don't build for me in unicode.
Now I'm yes fixing the inclusion of wide char support. It should be disabled only in i686-cygwin or cross compiling. svn path=/nixpkgs/branches/stdenv-updates/; revision=19277
2010-01-06 22:20:20 +00:00
unicode = (system != "i686-cygwin" && crossSystem == null);
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-17 22:58:48 +00:00
};
Add neon-0.29.x, make it default Also stop using "default" neon in all-packages.nix. Minor versions are not source-compatible, so a package should state needed version explicitly. svn path=/nixpkgs/trunk/; revision=21394
2010-04-28 09:40:19 +01:00
neon = neon029;
* Added Subversion 1.5.0. Some features probably don't work yet (building the Apache modules, building various language bindings). * Neon 0.28.2. Also kept Neon 0.26.x because Subversion 1.4.x needs it. svn path=/nixpkgs/trunk/; revision=12162
2008-06-19 16:29:25 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
neon026 = callPackage ../development/libraries/neon/0.26.nix {
* Added Subversion 1.5.0. Some features probably don't work yet (building the Apache modules, building various language bindings). * Neon 0.28.2. Also kept Neon 0.26.x because Subversion 1.4.x needs it. svn path=/nixpkgs/trunk/; revision=12162
2008-06-19 16:29:25 +01:00
compressionSupport = true;
sslSupport = true;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
neon028 = callPackage ../development/libraries/neon/0.28.nix {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
compressionSupport = true;
sslSupport = true;
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
neon029 = callPackage ../development/libraries/neon/0.29.nix {
Add neon-0.29.x, make it default Also stop using "default" neon in all-packages.nix. Minor versions are not source-compatible, so a package should state needed version explicitly. svn path=/nixpkgs/trunk/; revision=21394
2010-04-28 09:40:19 +01:00
compressionSupport = true;
sslSupport = true;
};
All-packages changes for last commits svn path=/nixpkgs/trunk/; revision=15561
2009-05-12 05:28:30 +01: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 17:26:58 +01:00
nettle = callPackage ../development/libraries/nettle { };
Add GNU Nettle, a cryptographic library. svn path=/nixpkgs/trunk/; revision=16127
2009-07-01 16:42:01 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
nspr = callPackage ../development/libraries/nspr { };
* Added NSPR, the Netscape Portable Runtime, and use it in Xulrunner and Firefox. * Xulrunner: don't install the tests. This saves a few megabytes. svn path=/nixpkgs/trunk/; revision=16173
2009-07-04 13:25:35 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
nss = callPackage ../development/libraries/nss { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
pkgs/top-level/all-packages.nix: strip trailing whitenspace svn path=/nixpkgs/trunk/; revision=23118
2010-08-11 16:49:42 +01:00
nssTools = callPackage ../development/libraries/nss {
updated nss and nspr, added variant of nss including tools svn path=/nixpkgs/trunk/; revision=23105
2010-08-11 10:38:09 +01:00
includeTools = true;
};
Added Open Dynamics Engine svn path=/nixpkgs/trunk/; revision=13520
2008-11-30 16:50:05 +00:00
ode = builderDefsPackage (import ../development/libraries/ode) {
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
openal = callPackage ../development/libraries/openal { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00: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 17:26:58 +01:00
openalSoft = callPackage ../development/libraries/openal-soft { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
openbabel = callPackage ../development/libraries/openbabel { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
opencascade = callPackage ../development/libraries/opencascade { };
Adding opencascade 6.4.0. svn path=/nixpkgs/trunk/; revision=13874
2009-01-27 08:14:27 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
openct = callPackage ../development/libraries/openct { };
Downgrading the opensc library version to 0.11.7, that required for the Spanish national id smartcard (DNIe). Adding the opensc dnie driver. svn path=/nixpkgs/trunk/; revision=19325
2010-01-10 00:22:29 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
opencv = callPackage ../development/libraries/opencv {
Fixing the gcc-wrapper, so it does not link when gcc is called with '-x something'. It should not link at least for '-x c-header' and '-x c++-header', and maybe link for '-x c' or '-x c++', but we expect noone will be linking using these later strings. Adding opencv, which required '-x c-header' working, and that's why I have updated gcc wrapper. svn path=/nixpkgs/branches/stdenv-updates/; revision=19491
2010-01-16 21:26:10 +00:00
inherit (gtkLibs) gtk glib;
inherit (gst_all) gstreamer;
pkgs/top-level/all-packages.nix: strip trailing white space svn path=/nixpkgs/trunk/; revision=21416
2010-04-29 09:54:02 +01:00
stdenv = stdenv2;
Fixing the gcc-wrapper, so it does not link when gcc is called with '-x something'. It should not link at least for '-x c-header' and '-x c++-header', and maybe link for '-x c' or '-x c++', but we expect noone will be linking using these later strings. Adding opencv, which required '-x c-header' working, and that's why I have updated gcc wrapper. svn path=/nixpkgs/branches/stdenv-updates/; revision=19491
2010-01-16 21:26:10 +00:00
};
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00: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 17:26:58 +01:00
openexr_ctl = callPackage ../development/libraries/openexr_ctl { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
openexr = callPackage ../development/libraries/openexr { };
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
openldap = callPackage ../development/libraries/openldap { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
Adding OpenLieroX svn path=/nixpkgs/trunk/; revision=16617
2009-08-08 19:18:33 +01:00
openlierox = builderDefsPackage ../games/openlierox {
inherit (xlibs) libX11 xproto;
xlock: fixed build and updated to version 5.24 svn path=/nixpkgs/trunk/; revision=17356
2009-09-22 21:16:38 +01:00
inherit gd SDL SDL_image SDL_mixer zlib libxml2
Adding OpenLieroX svn path=/nixpkgs/trunk/; revision=16617
2009-08-08 19:18:33 +01:00
pkgconfig;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
libopensc_dnie = callPackage ../development/libraries/libopensc-dnie {
Downgrading the opensc library version to 0.11.7, that required for the Spanish national id smartcard (DNIe). Adding the opensc dnie driver. svn path=/nixpkgs/trunk/; revision=19325
2010-01-10 00:22:29 +00:00
inherit (gtkLibs) glib;
opensc = opensc_0_11_7;
};
Adding 'mupdf', a lightweight PDF 1.7 viewer As a side effect, I add openjpeg and jbig2dec. svn path=/nixpkgs/trunk/; revision=23069
2010-08-09 21:59:38 +01:00
openjpeg = callPackage ../development/libraries/openjpeg { };
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
openssl = callPackage ../development/libraries/openssl {
* curl: build with OpenSSL (https) support by default. * Some fetchurl-related refactoring. The `realCurl' attribute is gone, `curl' is the real thing. To prevent an infinite recursion in `fetchurl' (because it depends on curl and building curl needs fetchurl), curl and its dependencies (openssl, zlib, perl) use `fetchurlBoot', which is the fetchurl used by the previous bootstrap phase (e.g. the statically linked version of curl for stdenv-linux). So as a result you can use https:// urls almost everywhere. There's also some hackery to prevent a different curl from being built in every stdenv-linux bootstrap phase (namely the stdenv.fetchurl attribute which allows fetchurl to be overriden everywhere). svn path=/nixpkgs/trunk/; revision=11905
2008-05-27 08:49:55 +01:00
fetchurl = fetchurlBoot;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ortp = callPackage ../development/libraries/ortp { };
ortp added svn path=/nixpkgs/trunk/; revision=10358
2008-01-28 19:49:08 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
pangoxsl = callPackage ../development/libraries/pangoxsl {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gtkLibs) glib pango;
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
pcre = callPackage ../development/libraries/pcre {
Removed legacy getFlag function svn path=/nixpkgs/trunk/; revision=10326
2008-01-28 19:36:15 +00:00
unicodeSupport = getConfig ["pcre" "unicode"] false;
* pcre: don't compile with C++ support when doing a dietlibc build. * GCC 4.2: restore the ability to build a statically linked compiler, needed for the Nixpkgs bootstrap. * GCC 4.2: use symlinks instead of hard links in $out/bin (NIXPKGS-62). svn path=/nixpkgs/branches/stdenv-updates/; revision=9771
2007-11-21 19:28:54 +00:00
cplusplusSupport = !stdenv ? isDietLibC;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
Added gdmap, changed builder-defs to use derivation attribute on propagatedBuildInputs, manually fixed Xorg expression problem for Compiz, various fixes. svn path=/nixpkgs/trunk/; revision=9812
2007-12-01 16:20:23 +00:00
Add phonon-backend-vlc svn path=/nixpkgs/trunk/; revision=22939
2010-08-04 11:04:40 +01:00
phonon_backend_vlc = callPackage ../development/libraries/phonon-backend-vlc {
vlc = vlc.override { qt4 = qt47; };
inherit (kde45) 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 17:26:58 +01:00
physfs = callPackage ../development/libraries/physfs { };
Updating neverball. That required adding physfs. svn path=/nixpkgs/trunk/; revision=18220
2009-11-06 19:25:45 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
plib = callPackage ../development/libraries/plib { };
PLIB: a suite of portable game libraries. svn path=/nixpkgs/trunk/; revision=13051
2008-10-12 15:27:51 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
podofo = callPackage ../development/libraries/podofo { };
Adding calibre. This involved also: - Adding podofo - Adding some new python packages - Making new pkgs attributes for python packages to build with python 2.6 - Updating some python packages expressions to allow python 2.6, and not only 2.5. svn path=/nixpkgs/trunk/; revision=19303
2010-01-07 22:47:30 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
polkit = callPackage ../development/libraries/polkit { };
* Added PolicyKit and eggdbus. There is a newer version of PolicyKit (0.93), but it doesn't compile with the current glib. svn path=/nixpkgs/trunk/; revision=16704
2009-08-13 08:55:11 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
policykit = callPackage ../development/libraries/policykit { };
Fix GConf from Gnome 2.26 svn path=/nixpkgs/trunk/; revision=16751
2009-08-17 19:31:42 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
poppler = callPackage ../development/libraries/poppler {
* pcre: don't compile with C++ support when doing a dietlibc build. * GCC 4.2: restore the ability to build a statically linked compiler, needed for the Nixpkgs bootstrap. * GCC 4.2: use symlinks instead of hard links in $out/bin (NIXPKGS-62). svn path=/nixpkgs/branches/stdenv-updates/; revision=9771
2007-11-21 19:28:54 +00:00
inherit (gtkLibs) glib gtk;
* qt-4 -> qt-4.4. * kde-4.2 shouldn't depend on poppler built with qt 4.5. svn path=/nixpkgs/trunk/; revision=17084
2009-09-13 12:04:54 +01:00
qt4Support = false;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
whoops, add libgcrypt and libotr here too svn path=/nixpkgs/trunk/; revision=9143
2007-08-16 22:45:10 +01:00
Remove old sip and pyqt svn path=/nixpkgs/trunk/; revision=21017
2010-04-11 22:03:51 +01:00
popplerQt4 = poppler.override {
inherit qt4;
Added my initial KDE 4.4 expression svn path=/nixpkgs/trunk/; revision=19906
2010-02-10 15:06:50 +00:00
qt4Support = 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 17:26:58 +01:00
popt = callPackage ../development/libraries/popt { };
Tried to add kuickshow (a pretty fast image viewer that used to be distributed by default in KDE). Unfortunately it doesn't work, because of some strange problems with mime types. But well, it compiles. The libraries are useful anyway: - arts (kde) - imlib (gnome) - libungif (aka libgif) svn path=/nixpkgs/trunk/; revision=6111
2006-08-13 10:46:54 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
proj = callPackage ../development/libraries/proj { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
postgis = callPackage ../development/libraries/postgis { };
adding postgis + script enabling postgis features Exporting builder.pl because it will be used in NixOS postgresql module svn path=/nixpkgs/trunk/; revision=21691
2010-05-09 21:38:16 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pth = callPackage ../development/libraries/pth { };
pth added svn path=/nixpkgs/trunk/; revision=10340
2008-01-28 19:43:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
qjson = callPackage ../development/libraries/qjson { };
Add qjson svn path=/nixpkgs/trunk/; revision=22451
2010-07-04 21:59:47 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
qt3 = callPackage ../development/libraries/qt-3 {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
openglSupport = mesaSupported;
qt3: use getConfig in mysqlSupport svn path=/nixpkgs/trunk/; revision=10357
2008-01-28 19:48:57 +00:00
mysqlSupport = getConfig ["qt" "mysql"] false;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use makeOverridable for the QT3 variants. svn path=/nixpkgs/branches/stdenv-updates/; revision=15194
2009-04-20 19:07:09 +01:00
qt3mysql = qt3.override {
* MythTV 0.21. svn path=/nixpkgs/trunk/; revision=12177
2008-06-23 10:01:04 +01:00
mysqlSupport = true;
};
Changed KDE 4.4.x to the default KDE version. Changed qt-4.6.x to the default qt4 version (except for the KDE 4.3.x attribute and older PyQt releases svn path=/nixpkgs/trunk/; revision=20404
2010-03-05 12:00:37 +00:00
qt4 = qt46;
* qt-4 -> qt-4.4. * kde-4.2 shouldn't depend on poppler built with qt 4.5. svn path=/nixpkgs/trunk/; revision=17084
2009-09-13 12:04:54 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
qt45 = callPackage ../development/libraries/qt-4.x/4.5 {
- Started my initial KDE 4.3.x expression which is a fork of the KDE 4.2.x expression - Also forked the qt-4.4.x expression and adapted it. The old qt-4.4.x cannot be replaced since KDE 4.2.x does not work with qt-4.5.x, but on the other hand KDE 4.3.x requires qt-4.5.x - It is now possible to disable the demos and examples in the qt-4.5.x build. By default, the demos, examples and documentation are disabled svn path=/nixpkgs/trunk/; revision=16723
2009-08-15 15:02:49 +01:00
inherit (gnome) glib;
};
xlock: fixed build and updated to version 5.24 svn path=/nixpkgs/trunk/; revision=17356
2009-09-22 21:16:38 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
qt46 = callPackage ../development/libraries/qt-4.x/4.6 {
Qt 4.6 svn path=/nixpkgs/trunk/; revision=19089
2009-12-24 09:49:35 +00:00
inherit (gnome) glib;
};
make qtscriptgenerator overridable svn path=/nixpkgs/trunk/; revision=19439
2010-01-14 14:51:02 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
qt47 = callPackage ../development/libraries/qt-4.x/4.7 {
Add qt-4.7-beta1 with low priority svn path=/nixpkgs/trunk/; revision=21659
2010-05-07 21:08:37 +01:00
inherit (gst_all) gstreamer gstPluginsBase;
inherit (gnome) glib;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
qtscriptgenerator = callPackage ../development/libraries/qtscriptgenerator {
Changed KDE 4.4.x to the default KDE version. Changed qt-4.6.x to the default qt4 version (except for the KDE 4.3.x attribute and older PyQt releases svn path=/nixpkgs/trunk/; revision=20404
2010-03-05 12:00:37 +00:00
qt4 = qt46;
- Added Qt script generator package (dependency for Amarok) - Added taglib-extras package (dependency for Amarok) - Upgraded Amarok to 2.1.1 svn path=/nixpkgs/trunk/; revision=17045
2009-09-11 13:05:23 +01:00
};
xlock: fixed build and updated to version 5.24 svn path=/nixpkgs/trunk/; revision=17356
2009-09-22 21:16:38 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
quassel = callPackage ../applications/networking/irc/quassel {
Added Quassel IRC client. By default it's compiled as monolithic, but as soon as there's a corresponding service, it should be changed to client/daemon split. svn path=/nixpkgs/trunk/; revision=22351
2010-06-21 00:48:59 +01:00
inherit (kde4) qt4 kdelibs phonon automoc4;
};
pkgs/top-level/all-packages.nix: stripped trailing whitespace svn path=/nixpkgs/trunk/; revision=22734
2010-07-26 14:41:09 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
quesoglc = callPackage ../development/libraries/quesoglc { };
quesoglc: New nixpkg. svn path=/nixpkgs/trunk/; revision=21580
2010-05-03 16:38:16 +01:00
Switch to Readline 6.0. svn path=/nixpkgs/branches/stdenv-updates/; revision=14209
2009-02-23 21:18:55 +00:00
readline = readline6;
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
readline4 = callPackage ../development/libraries/readline/readline4.nix { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
readline5 = callPackage ../development/libraries/readline/readline5.nix { };
Added Axis 1.3. svn path=/nixpkgs/trunk/; revision=5138
2006-04-03 14:02:05 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
readline6 = callPackage ../development/libraries/readline/readline6.nix { };
GNU Readline 6.0. svn path=/nixpkgs/branches/stdenv-updates/; revision=14208
2009-02-23 18:10:41 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
librdf_raptor = callPackage ../development/libraries/librdf/raptor.nix { };
pkgs/applications/editors/emacs-modes/magit: updated to version magit-0.7-94-gbf42bf8 Magit has seen plenty of development since version 0.7, but for some reason there haven't been any new releases. This version bump updates the expression to build a current version of Magit directly from the Git repository. This change adds buildInputs 'autoconf' and 'automake'. These tools are required only because we aren't building from a proper release tarball. Once version 0.8 comes out, these dependencies can be dropped again. svn path=/nixpkgs/trunk/; revision=20650
2010-03-16 12:13:40 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
librdf_rasqal = callPackage ../development/libraries/librdf/rasqal.nix { };
pkgs/applications/editors/emacs-modes/magit: updated to version magit-0.7-94-gbf42bf8 Magit has seen plenty of development since version 0.7, but for some reason there haven't been any new releases. This version bump updates the expression to build a current version of Magit directly from the Git repository. This change adds buildInputs 'autoconf' and 'automake'. These tools are required only because we aren't building from a proper release tarball. Once version 0.8 comes out, these dependencies can be dropped again. svn path=/nixpkgs/trunk/; revision=20650
2010-03-16 12:13:40 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
librdf = callPackage ../development/libraries/librdf { };
updating redland, adding rasqal, raptor, librdf svn path=/nixpkgs/trunk/; revision=17320
2009-09-21 10:58:21 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
qrupdate = callPackage ../development/libraries/qrupdate { };
added qrupdate, suitesparse needed to build octave from source svn path=/nixpkgs/trunk/; revision=22867
2010-08-02 12:20:39 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
redland = callPackage ../development/libraries/redland/1.0.10.nix {
Added my initial KDE 4.4 expression svn path=/nixpkgs/trunk/; revision=19906
2010-02-10 15:06:50 +00:00
bdb = db4;
* ltrace: updated to 0.5.3. * libdbi / libdbi-drivers: updated to 0.8.3, and make it compile with SQLite. * qemu-image: fix the URL. * gdmap: make it build again (requires an older GTK+). * rlwrap: updated to 0.37. * smbfs-fuse -> fusesmb to match the upstream name. * x11vnc: updated to 0.9.10. * clearlyU: fix the URL. * Various packages: follow the coding conventions. svn path=/nixpkgs/trunk/; revision=22814
2010-07-29 19:55:16 +01:00
postgresql = null;
Added my initial KDE 4.4 expression svn path=/nixpkgs/trunk/; revision=19906
2010-02-10 15:06:50 +00:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
rhino = callPackage ../development/libraries/java/rhino {
Add Mozilla Rhino. svn path=/nixpkgs/trunk/; revision=17884
2009-10-19 15:47:04 +01:00
ant = apacheAntGcj;
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 17:26:58 +01:00
rte = callPackage ../development/libraries/rte { };
* Added libcaca. * Libcaca support in MPlayer. * Hopefully fix X11 detection in MPlayer. svn path=/nixpkgs/trunk/; revision=3684
2005-08-24 16:02:30 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
rubberband = callPackage ../development/libraries/rubberband {
adding vamp sdk and rubberband svn path=/nixpkgs/trunk/; revision=17323
2009-09-21 10:58:30 +01: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 17:26:58 +01:00
schroedinger = callPackage ../development/libraries/schroedinger { };
update liboil to 0.3.13 (and add some (new) missing deps) add schroedinger, a free codec (might be moved to its own category instead of libs) svn path=/nixpkgs/trunk/; revision=11043
2008-03-10 20:13:44 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
SDL = callPackage ../development/libraries/SDL {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
openglSupport = mesaSupported;
alsaSupport = true;
* GNU parted: e2fsprogs -> libuuid. svn path=/nixpkgs/trunk/; revision=16694
2009-08-11 23:23:30 +01:00
pulseaudioSupport = false; # better go through ALSA
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
* Build splashutils properly. svn path=/nixpkgs/trunk/; revision=7134
2006-11-25 23:41:53 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
SDL_gfx = callPackage ../development/libraries/SDL_gfx { };
Add SDL_gfx. Contributed by Brian Gough <bjg@gnu.org>. svn path=/nixpkgs/trunk/; revision=21554
2010-05-02 10:27:45 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
SDL_image = callPackage ../development/libraries/SDL_image { };
Added libsigsegv svn path=/nixpkgs/trunk/; revision=1313
2004-08-23 10:35:36 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
SDL_mixer = callPackage ../development/libraries/SDL_mixer { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
SDL_net = callPackage ../development/libraries/SDL_net { };
forgot to update all-packages.nix svn path=/nixpkgs/trunk/; revision=10530
2008-02-06 21:26:17 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
SDL_sound = callPackage ../development/libraries/SDL_sound { };
Adding gltron. svn path=/nixpkgs/trunk/; revision=22519
2010-07-07 22:44:09 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
SDL_ttf = callPackage ../development/libraries/SDL_ttf { };
* Added libexif and the exif frontend utility. svn path=/nixpkgs/trunk/; revision=2376
2005-03-11 10:46:20 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
slang = callPackage ../development/libraries/slang { };
* Added sqlite, a "zero administration" database; I like the sound of that ;-) svn path=/nixpkgs/trunk/; revision=2377
2005-03-11 10:55:21 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
slibGuile = callPackage ../development/libraries/slib {
Add SLIB, a portable Scheme library. svn path=/nixpkgs/trunk/; revision=17546
2009-09-30 14:10:58 +01:00
scheme = guile;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
snack = callPackage ../development/libraries/snack {
added wavesurfer (sound analysis tool) and its dependency snack (tcl /python sound tool library) svn path=/nixpkgs/trunk/; revision=12904
2008-09-24 01:42:06 +01:00
# optional
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
speex = callPackage ../development/libraries/speex { };
whoops, add libgcrypt and libotr here too svn path=/nixpkgs/trunk/; revision=9143
2007-08-16 22:45:10 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
sqlite = callPackage ../development/libraries/sqlite {
svn path=/nixpkgs/trunk/; revision=22826
2010-07-30 14:05:52 +01:00
readline = null;
ncurses = null;
* Remove findutils-wrapper (obsolete). * Remove some unnecessary / inappropriate lowPrios. svn path=/nixpkgs/trunk/; revision=22825
2010-07-30 13:31:10 +01:00
};
Added an interactive variant of sqlite3 that has readline support enabled. svn path=/nixpkgs/trunk/; revision=19823
2010-02-04 16:07:15 +00:00
added older version of sqlite for use in DBD-SQLite perl package, which fails with newest one svn path=/nixpkgs/trunk/; revision=22989
2010-08-06 09:54:27 +01:00
sqlite36 = callPackage ../development/libraries/sqlite/3.6.x.nix {
readline = null;
ncurses = null;
};
pkgs/top-level/all-packages.nix: prefer sqliteInteractive in user environments, i.e. when running "nix-env -i sqlite" svn path=/nixpkgs/trunk/; revision=22944
2010-08-04 12:42:10 +01:00
sqliteInteractive = appendToName "interactive" (sqlite.override {
svn path=/nixpkgs/trunk/; revision=22826
2010-07-30 14:05:52 +01:00
inherit readline ncurses;
pkgs/top-level/all-packages.nix: prefer sqliteInteractive in user environments, i.e. when running "nix-env -i sqlite" svn path=/nixpkgs/trunk/; revision=22944
2010-08-04 12:42:10 +01:00
});
* Added ClearSilver 0.10.3. * Added SQLite 3.3. * Added PySQLite 2.2.2. * Added Trac 0.9.5. To get you started; a new project environment is created by executing: $ trac-admin /path/to/trac_project_env initenv Running the server can be done by executing: $ tracd --port 8000 /path/to/projectenv Trac is then available at http://localhost:8000/projectenv. More information available at http://www.edgewall.com/trac/. svn path=/nixpkgs/trunk/; revision=5195
2006-04-22 19:08:37 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
stlport = callPackage ../development/libraries/stlport { };
Move stlport to the top-level. svn path=/nixpkgs/trunk/; revision=12811
2008-09-05 18:17:00 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
suitesparse = callPackage ../development/libraries/suitesparse { };
added qrupdate, suitesparse needed to build octave from source svn path=/nixpkgs/trunk/; revision=22867
2010-08-02 12:20:39 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
t1lib = callPackage ../development/libraries/t1lib { };
* Added lcms, a color management system. svn path=/nixpkgs/trunk/; revision=2378
2005-03-11 11:02:31 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
taglib = callPackage ../development/libraries/taglib { };
Added gdmap, changed builder-defs to use derivation attribute on propagatedBuildInputs, manually fixed Xorg expression problem for Compiz, various fixes. svn path=/nixpkgs/trunk/; revision=9812
2007-12-01 16:20:23 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
taglib_extras = callPackage ../development/libraries/taglib-extras { };
- Added Qt script generator package (dependency for Amarok) - Added taglib-extras package (dependency for Amarok) - Upgraded Amarok to 2.1.1 svn path=/nixpkgs/trunk/; revision=17045
2009-09-11 13:05:23 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
talloc = callPackage ../development/libraries/talloc { };
talloc 2.0.1 svn path=/nixpkgs/trunk/; revision=22009
2010-05-27 20:33:28 +01:00
## tapioca_qt = import ../development/libraries/tapioca-qt {
## inherit stdenv fetchurl cmake qt4 telepathy_qt;
## };
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
tdb = callPackage ../development/libraries/tdb { };
TDB, the trivial database. svn path=/nixpkgs/trunk/; revision=19895
2010-02-10 11:28:18 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
tecla = callPackage ../development/libraries/tecla { };
maude, tecla, buddy: new packages Maude is a high-level specification language. Buddy and libtecla are required to build Maude. svn path=/nixpkgs/trunk/; revision=12358
2008-07-15 10:58:30 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
telepathy_gabble = callPackage ../development/libraries/telepathy-gabble { };
Added some telepathy+tapioca stuff. svn path=/nixpkgs/trunk/; revision=10360
2008-01-28 19:49:44 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
telepathy_glib = callPackage ../development/libraries/telepathy-glib { };
Added some telepathy+tapioca stuff. svn path=/nixpkgs/trunk/; revision=10360
2008-01-28 19:49:44 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
telepathy_qt = callPackage ../development/libraries/telepathy-qt { };
Added some telepathy+tapioca stuff. svn path=/nixpkgs/trunk/; revision=10360
2008-01-28 19:49:44 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
tk = callPackage ../development/libraries/tk { };
Added gdmap, changed builder-defs to use derivation attribute on propagatedBuildInputs, manually fixed Xorg expression problem for Compiz, various fixes. svn path=/nixpkgs/trunk/; revision=9812
2007-12-01 16:20:23 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
unixODBC = callPackage ../development/libraries/unixODBC { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
added unixODBCDrivers expression containing unixODBC Postgres connector driver integrating prior pkgs/development/libraries/mysql-connector-odbc/default.nix driver Also provides ini strings for assembling /etc/odbcinst.ini svn path=/nixpkgs/trunk/; revision=12044
2008-06-12 00:03:30 +01:00
unixODBCDrivers = recurseIntoAttrs (import ../development/libraries/unixODBCDrivers {
inherit fetchurl stdenv unixODBC glibc libtool openssl zlib;
* unixODBCDrivers needs sqlite. svn path=/nixpkgs/trunk/; revision=12072
2008-06-13 10:44:43 +01:00
inherit postgresql mysql sqlite;
added unixODBCDrivers expression containing unixODBC Postgres connector driver integrating prior pkgs/development/libraries/mysql-connector-odbc/default.nix driver Also provides ini strings for assembling /etc/odbcinst.ini svn path=/nixpkgs/trunk/; revision=12044
2008-06-12 00:03:30 +01:00
});
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
vamp = callPackage ../development/libraries/audio/vamp { };
adding vamp sdk and rubberband svn path=/nixpkgs/trunk/; revision=17323
2009-09-21 10:58:30 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
vigra = callPackage ../development/libraries/vigra { };
Adding Vigra svn path=/nixpkgs/trunk/; revision=22809
2010-07-29 15:38:39 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
vtk = callPackage ../development/libraries/vtk { };
Adding vtk-5.2.1, The Visualization Toolkit. svn path=/nixpkgs/trunk/; revision=14006
2009-02-08 16:27:57 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
vxl = callPackage ../development/libraries/vxl { };
Committing Lluís Batlle's submissions from mailing list posting <45219fb00901110456i6f21db35tbd1894eaea2146ff@mail.gmail.com>: * nixpkgs-ccrypt-1.7-new.patch * nixpkgs-cmake-add-ccmake.patch * nixpkgs-cpufrequtils-005-new.patch * nixpkgs-dwm-5.1-fix.patch * nixpkgs-freeimage-3.11.0-new.patch * nixpkgs-proxychains-3.1-new.patch * nixpkgs-psi-to-0.12.patch * nixpkgs-skype-to-2.0.0.72.patch * nixpkgs-truecrypt-6.1a-fix.patch * nixpkgs-vxl-1.11.0-new.patch * nixpkgs-xkb-popular-esperanto-symbols.patch * nixpkgs-xorg-via-video-fix.patch svn path=/nixpkgs/trunk/; revision=13751
2009-01-12 21:12:07 +00:00
Make WebKit use libsoup 2.31.2 via deepOverride. Edit a few packages that were overridable but did not allow extra arguments. Remove a catch with deepOverride that pkgs.lib had this attribute in a different sense. svn path=/nixpkgs/trunk/; revision=22529
2010-07-08 14:25:52 +01:00
webkit = ((builderDefsPackage ../development/libraries/webkit {
Now we have fresh GTK/Gnome; try updating WebKit svn path=/nixpkgs/trunk/; revision=17521
2009-09-30 06:37:09 +01:00
inherit (gnome28) gtkdoc libsoup;
* Make GTK 2.18 the default, and get rid of the deep overrides. (BTW, there seems to be a much cleaner solution than deepOverride, namely call all-packages.nix with an appropriate packageOverrides set.) svn path=/nixpkgs/branches/xorg-7.5/; revision=18025
2009-10-29 14:19:13 +00:00
inherit (gtkLibs) gtk atk pango glib;
openssh: Let $NIXPKGS_CONFIG determine whether OpenSSH supports PAM or not. PAM is enabled by default, as before. To disable it, set openssh { pam = false; }; or simply pam = false; in ~/.nixpkgs/config.nix. svn path=/nixpkgs/trunk/; revision=12312
2008-07-08 00:11:13 +01:00
inherit freetype fontconfig gettext gperf curl
libjpeg libtiff libpng libxml2 libxslt sqlite
icu cairo perl intltool automake libtool
Try updating WebKit. Dependency check passes; will abuse Hydra to build it all. svn path=/nixpkgs/trunk/; revision=22304
2010-06-17 06:20:16 +01:00
pkgconfig autoconf bison libproxy enchant
python ruby;
A case study in transitive overrides. WebKit needs fresh glib. This means it needs a whole slice of system built against glib-2.22.. Added overrides are generic enough, though. So the same way can be used to override everything. I have failed (so far?) to add mkOverridable into stdenv, though. svn path=/nixpkgs/trunk/; revision=17661
2009-10-06 06:43:51 +01:00
inherit (gst_all) gstreamer gstPluginsBase gstFfmpeg
Try to handle GStreamer correctly in webkit svn path=/nixpkgs/trunk/; revision=16544
2009-08-03 06:11:30 +01:00
gstPluginsGood;
Added WebKit; made it install webkit-program-GtkLauncher (originally it is just GtkLauncher) - minimalistic http/file-only browser which passes Acid3 svn path=/nixpkgs/trunk/; revision=12210
2008-06-29 08:02:11 +01:00
flex = flex2535;
Update WebKit and Midori svn path=/nixpkgs/trunk/; revision=15849
2009-06-04 12:20:26 +01:00
inherit (xlibs) libXt;
Make WebKit use libsoup 2.31.2 via deepOverride. Edit a few packages that were overridable but did not allow extra arguments. Remove a catch with deepOverride that pkgs.lib had this attribute in a different sense. svn path=/nixpkgs/trunk/; revision=22529
2010-07-08 14:25:52 +01:00
}).deepOverride {libsoup = gnome28.libsoup_2_31;});
Added WebKit; made it install webkit-program-GtkLauncher (originally it is just GtkLauncher) - minimalistic http/file-only browser which passes Acid3 svn path=/nixpkgs/trunk/; revision=12210
2008-06-29 08:02:11 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
wvstreams = callPackage ../development/libraries/wvstreams { };
adding wvdial, wvstreams, usb_modeswitch svn path=/nixpkgs/trunk/; revision=21131
2010-04-16 16:56:28 +01:00
Setting wxGTK to use the old gtk libs. Until wxGTK 2.8.11 they will not fix a symbol clash with glib 2.21. So we keep with glib 2.20. I also changed the default wxGTK from 2.6 to 2.8, caring so no hash is changed due to this change. Some packages using 2.6 may well build with 2.8, so we can try updating them for another commit. svn path=/nixpkgs/trunk/; revision=18133
2009-11-05 13:29:52 +00:00
wxGTK = wxGTK28;
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
wxGTK26 = callPackage ../development/libraries/wxGTK-2.6 {
Setting wxGTK to use the old gtk libs. Until wxGTK 2.8.11 they will not fix a symbol clash with glib 2.21. So we keep with glib 2.20. I also changed the default wxGTK from 2.6 to 2.8, caring so no hash is changed due to this change. Some packages using 2.6 may well build with 2.8, so we can try updating them for another commit. svn path=/nixpkgs/trunk/; revision=18133
2009-11-05 13:29:52 +00:00
inherit (gtkLibs216) gtk;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
wxGTK28 = callPackage ../development/libraries/wxGTK-2.8 {
Setting wxGTK to use the old gtk libs. Until wxGTK 2.8.11 they will not fix a symbol clash with glib 2.21. So we keep with glib 2.20. I also changed the default wxGTK from 2.6 to 2.8, caring so no hash is changed due to this change. Some packages using 2.6 may well build with 2.8, so we can try updating them for another commit. svn path=/nixpkgs/trunk/; revision=18133
2009-11-05 13:29:52 +00:00
inherit (gtkLibs216) gtk;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
wtk = callPackage ../development/libraries/wtk { };
Adding the Sun Wireless ToolKit for i686-linux at least. svn path=/nixpkgs/trunk/; revision=14666
2009-03-23 20:36:48 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
x264 = callPackage ../development/libraries/x264 { };
x264 codec lib added svn path=/nixpkgs/trunk/; revision=11876
2008-05-22 01:18:45 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xapian = callPackage ../development/libraries/xapian { };
adding xapian and xapian-bindings svn path=/nixpkgs/trunk/; revision=16788
2009-08-20 21:18:58 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xapianBindings = callPackage ../development/libraries/xapian/bindings { # TODO perl php Java, tcl, C#, python
adding xapian and xapian-bindings svn path=/nixpkgs/trunk/; revision=16788
2009-08-20 21:18:58 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
Xaw3d = callPackage ../development/libraries/Xaw3d {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
flex = flex2533;
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xineLib = callPackage ../development/libraries/xine-lib { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xautolock = callPackage ../misc/screensavers/xautolock { };
Added xautolock 2.1. Xautolock can be used to fire up a screen saver like xautolock after a certain period of inactivity. The tool probably doesn't belong into misc/screensavers, but I had no better idea. svn path=/nixpkgs/trunk/; revision=12305
2008-07-07 12:54:25 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
xercesJava = callPackage ../development/libraries/java/xerces {
Add Xerces-J, built from source. svn path=/nixpkgs/trunk/; revision=17562
2009-10-01 10:06:59 +01:00
ant = apacheAntGcj; # for bootstrap purposes
javac = gcj;
jvm = gcj;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
xlibsWrapper = callPackage ../development/libraries/xlibs-wrapper {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
packages = [
freetype fontconfig xlibs.xproto xlibs.libX11 xlibs.libXt
xlibs.libXft xlibs.libXext xlibs.libSM xlibs.libICE
xlibs.xextproto
];
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xvidcore = callPackage ../development/libraries/xvidcore { };
Adding xvid, to ffmpeg and mplayer. svn path=/nixpkgs/trunk/; revision=21469
2010-04-30 22:47:09 +01:00
All-packages changes for last commits svn path=/nixpkgs/trunk/; revision=15561
2009-05-12 05:28:30 +01:00
zangband = builderDefsPackage (import ../games/zangband) {
* Better not use stdenv.coreutils, since not every stdenv has a coreutils. svn path=/nixpkgs/trunk/; revision=15564
2009-05-12 10:45:24 +01:00
inherit ncurses flex bison autoconf automake m4 coreutils;
All-packages changes for last commits svn path=/nixpkgs/trunk/; revision=15561
2009-05-12 05:28:30 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
zlib = callPackage ../development/libraries/zlib {
* curl: build with OpenSSL (https) support by default. * Some fetchurl-related refactoring. The `realCurl' attribute is gone, `curl' is the real thing. To prevent an infinite recursion in `fetchurl' (because it depends on curl and building curl needs fetchurl), curl and its dependencies (openssl, zlib, perl) use `fetchurlBoot', which is the fetchurl used by the previous bootstrap phase (e.g. the statically linked version of curl for stdenv-linux). So as a result you can use https:// urls almost everywhere. There's also some hackery to prevent a different curl from being built in every stdenv-linux bootstrap phase (namely the stdenv.fetchurl attribute which allows fetchurl to be overriden everywhere). svn path=/nixpkgs/trunk/; revision=11905
2008-05-27 08:49:55 +01:00
fetchurl = fetchurlBoot;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
* Added libgphoto2. svn path=/nixpkgs/trunk/; revision=2379
2005-03-11 11:08:38 +00:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
zlibStatic = lowPrio (appendToName "static" (import ../development/libraries/zlib {
inherit fetchurl stdenv;
static = true;
}));
* Added `zapping', a TV viewer application. It depends on Gnome, so lots of packages are needed. svn path=/nixpkgs/trunk/; revision=681
2004-01-21 09:34:19 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
zvbi = callPackage ../development/libraries/zvbi {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
pngSupport = true;
};
add a bunch of tools svn path=/nixpkgs/trunk/; revision=6279
2006-08-27 20:59:45 +01:00
enable slang here... svn path=/nixpkgs/trunk/; revision=4439
2005-12-26 15:56:00 +00:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
### DEVELOPMENT / LIBRARIES / JAVA
* Added the Cairo graphics library. * Updated GTK and friends to 2.8.x. svn path=/nixpkgs/trunk/; revision=4073
2005-10-12 12:57:24 +01:00
add gtkLibs 2.10. This is not yet the default. svn path=/nixpkgs/trunk/; revision=5576
2006-07-04 17:58:25 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
atermjava = callPackage ../development/libraries/java/aterm {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
stdenv = overrideInStdenv stdenv [gnumake380];
* GTK 2.6 plus associated libraries. * Updated libtiff, libpng, libxml2, libxslt, gettext. svn path=/nixpkgs/trunk/; revision=2238
2005-02-15 16:22:20 +00:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
* Converted more packages. svn path=/nixpkgs/trunk/; revision=488
2003-11-06 15:24:19 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
commonsFileUpload = callPackage ../development/libraries/java/jakarta-commons/file-upload { };
Add FastJar. svn path=/nixpkgs/trunk/; revision=16469
2009-07-27 11:43:20 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
fastjar = callPackage ../development/tools/java/fastjar { };
Added libwmf for handling embedded graphics in .doc files. svn path=/nixpkgs/trunk/; revision=9153
2007-08-18 10:35:54 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
httpunit = callPackage ../development/libraries/java/httpunit { };
Added gwt-dragdrop library svn path=/nixpkgs/trunk/; revision=10856
2008-02-26 08:48:40 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gwtdragdrop = callPackage ../development/libraries/java/gwt-dragdrop { };
Added gwt-widgets svn path=/nixpkgs/trunk/; revision=10851
2008-02-25 12:45:17 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gwtwidgets = callPackage ../development/libraries/java/gwt-widgets { };
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
jakartabcel = callPackage ../development/libraries/java/jakarta-bcel {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
regexp = jakartaregexp;
};
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jakartaregexp = callPackage ../development/libraries/java/jakarta-regexp { };
* Add libxcrypt for Blowfish support in pam_unix2. svn path=/nixpkgs/trunk/; revision=7305
2006-12-11 02:35:05 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
javaCup = callPackage ../development/libraries/java/cup { };
* Some applications (notably, everything based on wxGTK) don't work yet with GTK 2.4. Fortunately, having several GTKs in parallel is no problem for Nix. svn path=/nixpkgs/trunk/; revision=915
2004-04-05 15:09:01 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
javasvn = callPackage ../development/libraries/java/javasvn { };
* Gnome terminal. svn path=/nixpkgs/trunk/; revision=8172
2007-03-04 23:37:34 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
jclasslib = callPackage ../development/tools/java/jclasslib {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
ant = apacheAnt14;
};
* Converted GTK 1 / Sylpheed, with optional support for gdk-pixbuf. svn path=/nixpkgs/trunk/; revision=490
2003-11-06 16:28:57 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jdom = callPackage ../development/libraries/java/jdom { };
add wmii window manager + all dependencies. Interesting excercise... svn path=/nixpkgs/trunk/; revision=8338
2007-03-18 23:58:22 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jflex = callPackage ../development/libraries/java/jflex { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
jjtraveler = callPackage ../development/libraries/java/jjtraveler {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
stdenv = overrideInStdenv stdenv [gnumake380];
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
junit = callPackage ../development/libraries/java/junit { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lucene = callPackage ../development/libraries/java/lucene { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mockobjects = callPackage ../development/libraries/java/mockobjects { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
saxon = callPackage ../development/libraries/java/saxon { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
saxonb = callPackage ../development/libraries/java/saxon/default8.nix { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
sharedobjects = callPackage ../development/libraries/java/shared-objects {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
stdenv = overrideInStdenv stdenv [gnumake380];
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
smack = callPackage ../development/libraries/java/smack { };
Added smack library svn path=/nixpkgs/trunk/; revision=10857
2008-02-26 09:07:12 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
swt = callPackage ../development/libraries/java/swt {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gtkLibs) gtk;
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
Xalan-J 2.7.1, built from source. svn path=/nixpkgs/trunk/; revision=17565
2009-10-01 10:07:17 +01:00
xalanj = xalanJava;
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
xalanJava = callPackage ../development/libraries/java/xalanj {
Xalan-J 2.7.1, built from source. svn path=/nixpkgs/trunk/; revision=17565
2009-10-01 10:07:17 +01: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 17:26:58 +01:00
xerces = xercesJava; };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
zziplib = callPackage ../development/libraries/zziplib { };
Add Zziplib. svn path=/nixpkgs/trunk/; revision=16528
2009-07-31 11:24:02 +01:00
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
### DEVELOPMENT / PERL MODULES
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* A function "buildPerlPackage" to replace all those "import ../development/perl-modules/generic perl" incantations. svn path=/nixpkgs/trunk/; revision=13387
2008-11-24 10:24:51 +00:00
buildPerlPackage = import ../development/perl-modules/generic perl;
Added maybench, an automated benchmarking tool. The tool depends on benchpress, a Haskell library for timed command execution. For starters, the expression lives in development/libraries/haskell/maybench. It doesn't really belong there because, though, because, technically, it's an executable, not a library. If someone has a better idea, please feel free to move it. svn path=/nixpkgs/trunk/; revision=12761
2008-08-29 10:05:49 +01:00
* Make Perl package show up in nix-env. svn path=/nixpkgs/trunk/; revision=15174
2009-04-20 13:24:13 +01:00
perlPackages = recurseIntoAttrs (import ./perl-packages.nix {
* Move all the Perl packages out of all-packages.nix into a separate file, perl-packages.nix. svn path=/nixpkgs/trunk/; revision=15171
2009-04-20 13:08:09 +01:00
inherit pkgs;
* Make Perl package show up in nix-env. svn path=/nixpkgs/trunk/; revision=15174
2009-04-20 13:24:13 +01:00
});
Added maybench, an automated benchmarking tool. The tool depends on benchpress, a Haskell library for timed command execution. For starters, the expression lives in development/libraries/haskell/maybench. It doesn't really belong there because, though, because, technically, it's an executable, not a library. If someone has a better idea, please feel free to move it. svn path=/nixpkgs/trunk/; revision=12761
2008-08-29 10:05:49 +01:00
* Drop the "perl" prefix from Perl attribute names. It's redundant now that Perl packages are in their own namespace (perlPackages.<pkg>). svn path=/nixpkgs/trunk/; revision=15176
2009-04-20 13:49:35 +01:00
perlXMLParser = perlPackages.XMLParser;
* added generic Cabal builder * transformed zlib, vty, binary, X11 to use generic Cabal builder * note that Cabal library packages are now by default prefixed with "haskell-" svn path=/nixpkgs/trunk/; revision=10247
2008-01-22 16:26:57 +00:00
add ack-1.92 patch provided by Francois Perrad svn path=/nixpkgs/trunk/; revision=20864
2010-03-30 00:36:38 +01:00
ack = perlPackages.ack;
* Added ghc-6.8.3 as the new default version of ghc. * Added a ghc HEAD snapshot (ghc-6.9.x). svn path=/nixpkgs/trunk/; revision=12391
2008-07-21 15:43:33 +01:00
add perlcritic 1.105 (and Test::Perl::Critic 1.02) and some depndencies: total perl libs added: BKeywords ConfigTiny ExceptionClass FileRemove FileWhich HookLexWrap IOString IPCRun3 PerlCritic PerlTidy PPI PodSpell ProbePerl ReadonlyXS RegexpParser StringFormat TestObject TestPerlCritic TestScript TestSubCalls patch provided by Francois Perrad svn path=/nixpkgs/trunk/; revision=20865
2010-03-30 00:36:40 +01:00
perlcritic = perlPackages.PerlCritic;
pkgs/top-level/all-packages.nix: stripped trailing whitespace svn path=/nixpkgs/trunk/; revision=22734
2010-07-26 14:41:09 +01:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
### DEVELOPMENT / PYTHON MODULES
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
pkgs/top-level/all-packages.nix: obsoleted setuptools_python26 and setuptools_python27 Instead of having different setuptools expressions, buildPythonPackage uses override to choose the desired python version. Now, technically, buildPythonPackage shouldn't exist in multiple versions either. Maybe the whole thing should be moved into python packages? svn path=/nixpkgs/trunk/; revision=23151
2010-08-12 15:01:51 +01:00
buildPythonPackage = import ../development/python-modules/generic {
inherit python setuptools makeWrapper lib;
};
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
pkgs/top-level/all-packages.nix: obsoleted setuptools_python26 and setuptools_python27 Instead of having different setuptools expressions, buildPythonPackage uses override to choose the desired python version. Now, technically, buildPythonPackage shouldn't exist in multiple versions either. Maybe the whole thing should be moved into python packages? svn path=/nixpkgs/trunk/; revision=23151
2010-08-12 15:01:51 +01:00
buildPython26Package = import ../development/python-modules/generic {
inherit makeWrapper lib;
python = python26;
setuptools = setuptools.override { python = python26; };
};
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
pkgs/top-level/all-packages.nix: obsoleted setuptools_python26 and setuptools_python27 Instead of having different setuptools expressions, buildPythonPackage uses override to choose the desired python version. Now, technically, buildPythonPackage shouldn't exist in multiple versions either. Maybe the whole thing should be moved into python packages? svn path=/nixpkgs/trunk/; revision=23151
2010-08-12 15:01:51 +01:00
buildPython27Package = import ../development/python-modules/generic {
inherit makeWrapper lib;
python = python27;
pkgs/top-level/all-packages.nix: disable doCheck for setuptools when run with Python 2.7 The regression test suite fails with the following error: ====================================================================== FAIL: test_get_script_header_jython_workaround (setuptools.tests.test_resources.ScriptHeaderTests) ---------------------------------------------------------------------- Traceback (most recent call last): File "/tmp/nix-build-0zz04maf217x7a6fq18ccmx5s1mrijlr-setuptools-0.6c11.drv-0/setuptools-0.6c11/setuptools/tests/test_resources.py", line 524, in test_get_script_header_jython_workaround self.assert_('Unable to adapt shebang line' in sys.stdout.getvalue()) AssertionError: False is not True I'm not sure yet what the problem is. svn path=/nixpkgs/trunk/; revision=23193
2010-08-16 18:03:19 +01:00
setuptools = setuptools.override { python = python27; doCheck = false; };
pkgs/top-level/all-packages.nix: obsoleted setuptools_python26 and setuptools_python27 Instead of having different setuptools expressions, buildPythonPackage uses override to choose the desired python version. Now, technically, buildPythonPackage shouldn't exist in multiple versions either. Maybe the whole thing should be moved into python packages? svn path=/nixpkgs/trunk/; revision=23151
2010-08-12 15:01:51 +01:00
};
Added Python version 2.7. svn path=/nixpkgs/trunk/; revision=23117
2010-08-11 16:49:03 +01:00
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
pythonPackages = python26Packages;
python25Packages = recurseIntoAttrs (import ./python-packages.nix {
inherit pkgs python buildPythonPackage;
Adding calibre. This involved also: - Adding podofo - Adding some new python packages - Making new pkgs attributes for python packages to build with python 2.6 - Updating some python packages expressions to allow python 2.6, and not only 2.5. svn path=/nixpkgs/trunk/; revision=19303
2010-01-07 22:47:30 +00:00
});
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
python26Packages = recurseIntoAttrs (import ./python-packages.nix {
inherit pkgs;
Adding calibre. This involved also: - Adding podofo - Adding some new python packages - Making new pkgs attributes for python packages to build with python 2.6 - Updating some python packages expressions to allow python 2.6, and not only 2.5. svn path=/nixpkgs/trunk/; revision=19303
2010-01-07 22:47:30 +00:00
python = python26;
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
buildPythonPackage = buildPython26Package;
Change Nevow, SimpleJSON, and Foolscap to use `buildPythonPackage'. svn path=/nixpkgs/trunk/; revision=15707
2009-05-24 22:08:39 +01:00
});
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
Added Python version 2.7. svn path=/nixpkgs/trunk/; revision=23117
2010-08-11 16:49:03 +01:00
python27Packages = recurseIntoAttrs (import ./python-packages.nix {
inherit pkgs;
python = python27;
buildPythonPackage = buildPython27Package;
});
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
foursuite = callPackage ../development/python-modules/4suite { };
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
bsddb3 = callPackage ../development/python-modules/bsddb3 { };
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
flup = builderDefsPackage ../development/python-modules/flup {
flup and ViewMTN seem to work just as well with default Python svn path=/nixpkgs/trunk/; revision=23119
2010-08-11 17:28:53 +01:00
inherit fetchurl stdenv python setuptools;
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
numeric = callPackage ../development/python-modules/numeric { };
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pil = callPackage ../development/python-modules/pil { };
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
psyco = callPackage ../development/python-modules/psyco { };
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pycairo = callPackage ../development/python-modules/pycairo { };
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pycrypto = callPackage ../development/python-modules/pycrypto { };
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pycups = callPackage ../development/python-modules/pycups { };
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pygame = callPackage ../development/python-modules/pygame { };
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pygobject = callPackage ../development/python-modules/pygobject { };
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
pygtk = callPackage ../development/python-modules/pygtk {
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
inherit (gtkLibs) glib gtk;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
pyGtkGlade = callPackage ../development/python-modules/pygtk {
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
inherit (gtkLibs) glib gtk;
inherit (gnome) libglade;
};
pyopenssl = builderDefsPackage (import ../development/python-modules/pyopenssl) {
inherit python 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 17:26:58 +01:00
rhpl = callPackage ../development/python-modules/rhpl { };
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
sip = callPackage ../development/python-modules/python-sip { };
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pyqt4 = callPackage ../development/python-modules/pyqt { };
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pyx = callPackage ../development/python-modules/pyx { };
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pyxml = callPackage ../development/python-modules/pyxml { };
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
setuptools = builderDefsPackage (import ../development/python-modules/setuptools) {
inherit python makeWrapper;
};
- adding experimental python31 build - cleanup python libraries: * moving all python libraries into a attr set into a directory so that expressions can be used for both: python 2.5 and 2.6 easily * disabling packages which don't build svn path=/nixpkgs/trunk/; revision=21142
2010-04-17 19:28:25 +01:00
wxPython = wxPython26;
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
wxPython26 = callPackage ../development/python-modules/wxPython/2.6.nix {
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
wxGTK = wxGTK26;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
wxPython28 = callPackage ../development/python-modules/wxPython/2.8.nix { };
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
twisted = pythonPackages.twisted;
ZopeInterface = pythonPackages.zopeInterface;
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
zope = callPackage ../development/python-modules/zope {
* Reverted most of the recent Python refactorings, as discussed. It's a worthy goal to move the Python packages that are currently in all-packages.nix into a single attribute set, but this doesn't require moving python-packages.nix or the other changes made to that file. The Python packages in all-packages.nix should simply be moved to python-packages.nix, and ideally changed to use buildPythonPackage. svn path=/nixpkgs/trunk/; revision=21196
2010-04-21 11:51:15 +01:00
python = python24;
};
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
### SERVERS
Added SVK. svn path=/nixpkgs/trunk/; revision=11937
2008-05-30 19:15:25 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
rdf4store = callPackage ../servers/http/4store {
Adding 4store RDF storage/SparQL server svn path=/nixpkgs/trunk/; revision=22434
2010-06-30 22:51:48 +01:00
inherit (gtkLibs) glib;
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
apacheHttpd = callPackage ../servers/http/apache-httpd {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
sslSupport = true;
* Updated some Catalyst packages. svn path=/nixpkgs/trunk/; revision=14137
2009-02-20 10:56:47 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
sabnzbd = callPackage ../servers/sabnzbd { };
Added sabnzbd usenet download tool :) svn path=/nixpkgs/trunk/; revision=18294
2009-11-08 19:55:37 +00:00
* Removed selectVersion. There's no good reason to write `selectVersion ./foo "bar"' instead of `import ./foo/bar.nix'. * Replaced `with args' with formal function arguments in several packages. * Renamed several files to `default.nix'. As a general rule, version numbers should only be included in the filename when there is a reason to keep multiple versions of a package in Nixpkgs. Otherwise, it just makes it harder to update the package. svn path=/nixpkgs/trunk/; revision=18403
2009-11-18 09:39:59 +00:00
bind = builderDefsPackage (import ../servers/dns/bind/9.5.0.nix) {
Added BIND svn path=/nixpkgs/trunk/; revision=12064
2008-06-12 19:10:08 +01:00
inherit openssl libtool;
* Latest Catalyst packages, include FormFu and its gazillion dependencies. svn path=/nixpkgs/trunk/; revision=14042
2009-02-12 15:59:22 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dico = callPackage ../servers/dico { };
* Latest Catalyst packages, include FormFu and its gazillion dependencies. svn path=/nixpkgs/trunk/; revision=14042
2009-02-12 15:59:22 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dict = callPackage ../servers/dict { };
Added dict and working on adding dictionaries svn path=/nixpkgs/trunk/; revision=10976
2008-03-06 04:39:05 +00:00
dictdDBs = recurseIntoAttrs (import ../servers/dict/dictd-db.nix {
inherit builderDefs;
});
Updated: RelFS. Added DictDB aggregation. svn path=/nixpkgs/trunk/; revision=11006
2008-03-07 06:11:08 +00: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 17:26:58 +01:00
dovecot = callPackage ../servers/mail/dovecot { };
dovecot_1_1_1 = callPackage ../servers/mail/dovecot/1.1.1.nix { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
ejabberd = callPackage ../servers/xmpp/ejabberd {
Ejabberd will use old Erlang for now svn path=/nixpkgs/trunk/; revision=22477
2010-07-05 13:47:35 +01:00
erlang = erlangR13B ;
Added erlang/ejabberd packages svn path=/nixpkgs/trunk/; revision=10258
2008-01-23 10:06:07 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
couchdb = callPackage ../servers/http/couchdb { };
pkgs/top-level/all-packages.nix: strip trailing white space svn path=/nixpkgs/trunk/; revision=21416
2010-04-29 09:54:02 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
felix = callPackage ../servers/felix { };
pkgs/top-level/all-packages.nix: strip trailing white space svn path=/nixpkgs/trunk/; revision=21416
2010-04-29 09:54:02 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
felix_remoteshell = callPackage ../servers/felix/remoteshell.nix { };
added couchdb 0.8.1-incubating svn path=/nixpkgs/trunk/; revision=18141
2009-11-05 14:41:05 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
fingerd_bsd = callPackage ../servers/fingerd/bsd-fingerd { };
finger client and daemon added svn path=/nixpkgs/trunk/; revision=10364
2008-01-28 19:51:14 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
firebird = callPackage ../servers/firebird { };
adding firebird (and embedded library ?) svn path=/nixpkgs/trunk/; revision=22130
2010-06-03 16:19:56 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ircdHybrid = callPackage ../servers/irc/ircd-hybrid { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jboss = callPackage ../servers/http/jboss { };
Added JBoss svn path=/nixpkgs/trunk/; revision=10259
2008-01-23 12:25:08 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jboss_mysql_jdbc = callPackage ../servers/http/jboss/jdbc/mysql { };
Added MySQL driver link to JBoss svn path=/nixpkgs/trunk/; revision=10374
2008-01-29 11:11:26 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jetty = callPackage ../servers/http/jetty { };
added: dnsmasq, uisp, fltk libixp_for_wmii, acerhk kernel module, reiserfsprogs, radeontools, msmtp, procmail, pstree, gxemul changed: umlutilities to also support building tunctl optionally (needing kernel header files) wmii updated and wmiimenu added svn path=/nixpkgs/trunk/; revision=9242
2007-09-03 13:10:57 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jetty61 = callPackage ../servers/http/jetty/6.1 { };
Added jetty 6.1 svn path=/nixpkgs/trunk/; revision=10858
2008-02-26 09:26:17 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lighttpd = callPackage ../servers/http/lighttpd { };
added lighthttpd svn path=/nixpkgs/trunk/; revision=12907
2008-09-24 01:42:50 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mod_python = callPackage ../servers/http/apache-modules/mod_python { };
Added libzip svn path=/nixpkgs/trunk/; revision=9637
2007-11-11 16:19:00 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mpd = callPackage ../servers/mpd { };
mpd: New nixpkg. svn path=/nixpkgs/trunk/; revision=21148
2010-04-18 20:26:30 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
myserver = callPackage ../servers/http/myserver { };
Add GNU MyServer. svn path=/nixpkgs/trunk/; revision=16801
2009-08-21 11:20:40 +01:00
Added nginx - lightweight http server svn path=/nixpkgs/trunk/; revision=13518
2008-11-30 09:06:53 +00:00
nginx = builderDefsPackage (import ../servers/http/nginx) {
inherit openssl pcre zlib libxml2 libxslt;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
postfix = callPackage ../servers/mail/postfix { };
Added Postfix to all-packages.nix svn path=/nixpkgs/trunk/; revision=12069
2008-06-13 05:31:31 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
pulseaudio = callPackage ../servers/pulseaudio {
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
inherit (gtkLibs) gtk glib; # Needs ALSA >= 1.0.17.
Add PulseAudio, an audio server. svn path=/nixpkgs/trunk/; revision=13659
2008-12-19 14:56:37 +00: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 17:26:58 +01:00
tomcat_connectors = callPackage ../servers/http/apache-modules/tomcat-connectors { };
Added apache tomcat connector module svn path=/nixpkgs/trunk/; revision=10260
2008-01-23 14:40:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
portmap = callPackage ../servers/portmap { };
Add portmap, an ONC RPC directory service. svn path=/nixpkgs/trunk/; revision=11138
2008-03-15 22:51:46 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
monetdb = callPackage ../servers/sql/monetdb { };
adding monetdb database svn path=/nixpkgs/trunk/; revision=16262
2009-07-09 04:50:44 +01:00
MySQL5 should be default already. svn path=/nixpkgs/branches/stdenv-updates-merge/; revision=10846
2008-02-25 03:16:07 +00:00
mysql4 = import ../servers/sql/mysql {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit fetchurl stdenv ncurses zlib perl;
ps = procps; /* !!! Linux only */
};
Added log4cxx library svn path=/nixpkgs/trunk/; revision=9638
2007-11-11 16:22:29 +00:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
mysql5 = import ../servers/sql/mysql5 {
* Merged most of the stdenv-updates branch. Some stuff didn't merge cleanly right away (kde-4, kernel stuff) so it should be merged later. But the stdenv stuff is all there. svn path=/nixpkgs/branches/stdenv-updates-merge/; revision=10793
2008-02-20 23:02:41 +00:00
inherit fetchurl stdenv ncurses zlib perl openssl;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
ps = procps; /* !!! Linux only */
};
Added lzo library svn path=/nixpkgs/trunk/; revision=9636
2007-11-11 16:17:21 +00:00
mysql 5.1.41 svn path=/nixpkgs/trunk/; revision=19017
2009-12-17 18:54:12 +00:00
mysql51 = import ../servers/sql/mysql51 {
inherit fetchurl ncurses zlib perl openssl stdenv;
ps = procps; /* !!! Linux only */
};
MySQL5 should be default already. svn path=/nixpkgs/branches/stdenv-updates-merge/; revision=10846
2008-02-25 03:16:07 +00:00
mysql = mysql5;
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mysql_jdbc = callPackage ../servers/sql/mysql/jdbc { };
Added libraries: - gtkmm: C++ bindings for gtk - glibmm: C++ bindings for glib - libsigc++ (C++) Added applications: - Batik: SVG rasterizer (and more) - Inkscape: vector graphics drawing application Upgraded: - boehm-gc svn path=/nixpkgs/trunk/; revision=3792
2005-09-07 15:57:30 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
nagios = callPackage ../servers/monitoring/nagios {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
gdSupport = true;
};
* Build the i810 driver. Only depend on the Mesa headers, not all of Mesa. svn path=/nixpkgs/trunk/; revision=8060
2007-02-26 23:10:25 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
nagiosPluginsOfficial = callPackage ../servers/monitoring/nagios/plugins/official { };
Added pangoxsl and xmlroff svn path=/nixpkgs/trunk/; revision=3574
2005-08-13 22:35:49 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
openfire = callPackage ../servers/xmpp/openfire { };
svn path=/nixpkgs/branches/stdenv-updates-merge/; revision=10811
2008-02-21 16:24:44 +00:00
* Postgres updated to 8.3.8 and 8.4.1. Dropped the "with args" and "version" argument. Added a few Postgres mirrors. svn path=/nixpkgs/trunk/; revision=17804
2009-10-14 15:38:16 +01: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 17:26:58 +01:00
postgresql83 = callPackage ../servers/sql/postgresql/8.3.x.nix { };
* added postgresql 8.4.0 svn path=/nixpkgs/trunk/; revision=16956
2009-09-04 13:55:03 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
postgresql84 = callPackage ../servers/sql/postgresql/8.4.x.nix { };
add a variant of qt without mysql support svn path=/nixpkgs/trunk/; revision=5462
2006-06-17 23:04:42 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
postgresql_jdbc = callPackage ../servers/sql/postgresql/jdbc { };
* Added Qt 3.3.3. Basic installation, except that Xrender and Xft support are enabled (for anti-aliased fonts). BUG: Qt currently searches for plugins and documentation in the temporary build directory, instead of in its prefix. So, e.g., help in Qt Designer doesn't work. svn path=/nixpkgs/trunk/; revision=2066
2005-01-19 22:51:27 +00:00
Added xmpppy - python XMPP library and pyIRCt - python IRC transport svn path=/nixpkgs/trunk/; revision=15005
2009-04-13 00:27:55 +01:00
pyIRCt = builderDefsPackage (import ../servers/xmpp/pyIRCt) {
inherit xmpppy pythonIRClib python makeWrapper;
};
pyMAILt = builderDefsPackage (import ../servers/xmpp/pyMAILt) {
inherit xmpppy python makeWrapper 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 17:26:58 +01:00
radius = callPackage ../servers/radius { };
Add GNU Shishi and GNU Radius. Contributed by Brian Gough <bjg@gnu.org>. svn path=/nixpkgs/trunk/; revision=21313
2010-04-26 09:45:23 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
redstore = callPackage ../servers/http/redstore { };
Adding Redstore HTTP RDF/SPARQL server svn path=/nixpkgs/trunk/; revision=22428
2010-06-29 23:18:49 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
samba = callPackage ../servers/samba { };
wip: kdelibs svn path=/nixpkgs/trunk/; revision=4261
2005-11-12 14:52:16 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
shishi = callPackage ../servers/shishi { };
Add GNU Shishi and GNU Radius. Contributed by Brian Gough <bjg@gnu.org>. svn path=/nixpkgs/trunk/; revision=21313
2010-04-26 09:45:23 +01:00
squid update. Proposal for multiple versions svn path=/nixpkgs/trunk/; revision=13666
2008-12-21 16:36:47 +00:00
squids = recurseIntoAttrs( import ../servers/squid/squids.nix {
inherit fetchurl stdenv perl lib composableDerivation;
});
squid = squids.squid3Beta; # has ipv6 support
top-level changes .. svn path=/nixpkgs/trunk/; revision=11829
2008-05-15 18:51:41 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
tomcat5 = callPackage ../servers/http/tomcat { };
* MonoDevelop (from SVN). svn path=/nixpkgs/trunk/; revision=2356
2005-03-09 17:49:19 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
tomcat6 = callPackage ../servers/http/tomcat/6.0.nix { };
Added Apache Tomcat 6.0 svn path=/nixpkgs/trunk/; revision=10400
2008-01-30 09:41:33 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
tomcat_mysql_jdbc = callPackage ../servers/http/tomcat/jdbc/mysql { };
Added shared JDBC driver support for tomcat svn path=/nixpkgs/trunk/; revision=12476
2008-08-04 13:04:24 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
axis2 = callPackage ../servers/http/tomcat/axis2 { };
Added Apache Axis2 svn path=/nixpkgs/trunk/; revision=10493
2008-02-04 12:24:41 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
virtuoso = callPackage ../servers/sql/virtuoso { };
Add virtuoso database Very minimal installation needed by KDE svn path=/nixpkgs/trunk/; revision=20932
2010-04-03 18:34:14 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
vsftpd = callPackage ../servers/ftp/vsftpd { };
* development/libraries/gnome/*: upgraded all gnome packages to 2.8.3. * development/libraries/gnome/*: copied gtk packages to gnome directory. gnome 2.8.3 did not work on gtk 2.4 nor gtk 2.6. Using the specific version of the gnome platform 2.8.3 directory 'solved' the issue. * development/libraries/gnome/gnome-icon-theme: new packag * development/libraries/gnome/libgtkhtml: new package * development/libraries/gnome/gtkhtml: new package * development/libraries/gnome/libgnomeprint: new package * development/libraries/gnome/libgnomeprintui: new package * development/libraries/gnome/gnome-keyring: new package * development/libraries/gnome/gail: new package * applications/editors/monodoc: new package svn path=/nixpkgs/trunk/; revision=2312
2005-02-26 23:45:19 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xinetd = callPackage ../servers/xinetd { };
Adding the xinetd package. svn path=/nixpkgs/trunk/; revision=16779
2009-08-19 21:19:17 +01:00
* X.org 7.4. svn path=/nixpkgs/branches/stdenv-updates/; revision=13006
2008-10-08 18:02:48 +01:00
xorg = recurseIntoAttrs (import ../servers/x11/xorg/default.nix {
Using openchrome trunk instead of that distributed with xorg. That doesn't work in K8N800, and trunk even does a bit of 3D by hw. svn path=/nixpkgs/trunk/; revision=16329
2009-07-11 11:32:27 +01:00
inherit fetchurl fetchsvn stdenv pkgconfig freetype fontconfig
* Updated mesa to 7.6.1. * Removed mesa-headers as it's not used anymore. svn path=/nixpkgs/trunk/; revision=19389
2010-01-13 12:43:17 +00:00
libxslt expat libdrm libpng zlib perl mesa
Using openchrome trunk instead of that distributed with xorg. That doesn't work in K8N800, and trunk even does a bit of 3D by hw. svn path=/nixpkgs/trunk/; revision=16329
2009-07-11 11:32:27 +01:00
xkeyboard_config dbus hal libuuid openssl gperf m4
* Updated the X.org server to 1.8.2. Note that it no longer depends on HAL but instead uses udev to autoconfigure input devices. We'll have to update the NixOS X server module accordingly, I guess. See https://fedoraproject.org/wiki/Input_device_configuration. * Updated Mesa to 7.8.2. svn path=/nixpkgs/branches/x-updates/; revision=22681
2010-07-20 20:24:21 +01:00
automake autoconf libtool xmlto asciidoc udev;
Fix xlibs-wrapper infinite loop when python.full is set to true. svn path=/nixpkgs/trunk/; revision=15411
2009-04-30 09:29:29 +01:00
# !!! pythonBase is use instead of python because this cause an infinite
# !!! recursion when the flag python.full is set to true. Packages
# !!! contained in the loop are python, tk, xlibs-wrapper, libX11,
# !!! libxcd (and xcb-proto).
python = pythonBase;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
});
source fixed of ilmbase and openexr, blender, openal-soft added (can't compile openal yet on x64) svn path=/nixpkgs/trunk/; revision=9811
2007-12-01 05:56:58 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xorgReplacements = callPackage ../servers/x11/xorg/replacements.nix { };
Made it easy to build custom xf86videoati version svn path=/nixpkgs/trunk/; revision=13112
2008-10-25 08:19:07 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xorgVideoUnichrome = callPackage ../servers/x11/xorg/unichrome/default.nix { };
Adding the Unichrome xorg video driver, and updating the Openchrome. svn path=/nixpkgs/trunk/; revision=18161
2009-11-05 21:34:31 +00:00
* Zabbix updated to 1.8.1. svn path=/nixpkgs/trunk/; revision=20009
2010-02-15 14:20:28 +00:00
zabbix = recurseIntoAttrs (import ../servers/monitoring/zabbix {
inherit fetchurl stdenv pkgconfig postgresql curl openssl zlib;
});
* Added Zabbix, a system and network monitoring tool. svn path=/nixpkgs/trunk/; revision=11963
2008-06-03 22:59:35 +01:00
Openbabel added. There are some TODO's in its nix-expression. svn path=/nixpkgs/trunk/; revision=9635
2007-11-11 16:15:29 +00:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
### OS-SPECIFIC
exrviewer added (needs ctl openexr openexr_ctl) fltk update ilmbase updated ndiswrapper does compile but has to be integrated into the kernel somehow svn path=/nixpkgs/trunk/; revision=9863
2007-12-05 21:25:47 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
afuse = callPackage ../os-specific/linux/afuse { };
adding afuse. A userspace automounter svn path=/nixpkgs/trunk/; revision=19063
2009-12-21 08:55:27 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
autofs5 = callPackage ../os-specific/linux/autofs/autofs-v5.nix { };
adding automount 5 svn path=/nixpkgs/trunk/; revision=15410
2009-04-30 03:37:00 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
_915resolution = callPackage ../os-specific/linux/915resolution { };
* Added openldap and pam_ldap. svn path=/nixpkgs/trunk/; revision=7641
2007-01-11 21:55:29 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
nfsUtils = callPackage ../os-specific/linux/nfs-utils { };
* Added gtksourceview and gtksourceview-sharp. svn path=/nixpkgs/trunk/; revision=2344
2005-03-08 15:44:23 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
acpi = callPackage ../os-specific/linux/acpi { };
Add ACPI, a tiny ACPI client tool for Linux svn path=/nixpkgs/trunk/; revision=10820
2008-02-21 20:13:36 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
acpid = callPackage ../os-specific/linux/acpid { };
* Added acpid, a daemon that monitors ACPI events. svn path=/nixpkgs/trunk/; revision=14026
2009-02-10 23:12:18 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
acpitool = callPackage ../os-specific/linux/acpitool { };
Add ACPI-Tool, a command-line ACPI client for Linux. svn path=/nixpkgs/trunk/; revision=10819
2008-02-21 19:57:40 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
alsaLib = callPackage ../os-specific/linux/alsa-lib { };
all-packages.nix: commented out package 'vice' error: getting status of `/usr/local/src/nix-pkgs-current/pkgs/misc/emulators/vice': No such file or directory svn path=/nixpkgs/trunk/; revision=15646
2009-05-18 14:53:01 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
alsaPlugins = callPackage ../os-specific/linux/alsa-plugins { };
alsaPluginWrapper = callPackage ../os-specific/linux/alsa-plugins/wrapper.nix { };
adding alsa-plugin and patching alsa so that you can tell it about additional plugins svn path=/nixpkgs/trunk/; revision=17316
2009-09-20 22:54:23 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
alsaUtils = callPackage ../os-specific/linux/alsa-utils { };
- svn path=/nixpkgs/branches/stdenv-updates-merge/; revision=10823
2008-02-22 03:06:12 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
bluez = callPackage ../os-specific/linux/bluez { };
* Added bluez, the Bluetooth stack for Linux. svn path=/nixpkgs/trunk/; revision=16594
2009-08-05 21:29:36 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
bridge_utils = callPackage ../os-specific/linux/bridge_utils { };
* Added `zapping', a TV viewer application. It depends on Gnome, so lots of packages are needed. svn path=/nixpkgs/trunk/; revision=681
2004-01-21 09:34:19 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cifs_utils = callPackage ../os-specific/linux/cifs-utils { };
* Added cifs-utils (mount.cifs properly packaged). This obsoletes mount-cifs. svn path=/nixpkgs/trunk/; revision=22124
2010-06-03 15:28:48 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
conky = callPackage ../os-specific/linux/conky {
conky: compiled without X support, usefull with dwm. svn path=/nixpkgs/trunk/; revision=22015
2010-05-27 20:33:58 +01:00
inherit (gtkLibs) glib;
};
Trying to reinstate the meta-based Hydra builds svn path=/nixpkgs/trunk/; revision=16883
2009-08-28 07:29:21 +01:00
cpufrequtils = (
Attempt to mark up packages with platform assertions svn path=/nixpkgs/trunk/; revision=16850
2009-08-25 07:36:05 +01:00
import ../os-specific/linux/cpufrequtils {
Committing Lluís Batlle's submissions from mailing list posting <45219fb00901110456i6f21db35tbd1894eaea2146ff@mail.gmail.com>: * nixpkgs-ccrypt-1.7-new.patch * nixpkgs-cmake-add-ccmake.patch * nixpkgs-cpufrequtils-005-new.patch * nixpkgs-dwm-5.1-fix.patch * nixpkgs-freeimage-3.11.0-new.patch * nixpkgs-proxychains-3.1-new.patch * nixpkgs-psi-to-0.12.patch * nixpkgs-skype-to-2.0.0.72.patch * nixpkgs-truecrypt-6.1a-fix.patch * nixpkgs-vxl-1.11.0-new.patch * nixpkgs-xkb-popular-esperanto-symbols.patch * nixpkgs-xorg-via-video-fix.patch svn path=/nixpkgs/trunk/; revision=13751
2009-01-12 21:12:07 +00:00
inherit fetchurl stdenv libtool gettext;
glibc = stdenv.gcc.libc;
Replace `kernelHeaders' by `linuxHeaders'. svn path=/nixpkgs/branches/stdenv-updates/; revision=19067
2009-12-21 14:04:45 +00:00
linuxHeaders = stdenv.gcc.libc.kernelHeaders;
Attempt to mark up packages with platform assertions svn path=/nixpkgs/trunk/; revision=16850
2009-08-25 07:36:05 +01:00
});
Committing Lluís Batlle's submissions from mailing list posting <45219fb00901110456i6f21db35tbd1894eaea2146ff@mail.gmail.com>: * nixpkgs-ccrypt-1.7-new.patch * nixpkgs-cmake-add-ccmake.patch * nixpkgs-cpufrequtils-005-new.patch * nixpkgs-dwm-5.1-fix.patch * nixpkgs-freeimage-3.11.0-new.patch * nixpkgs-proxychains-3.1-new.patch * nixpkgs-psi-to-0.12.patch * nixpkgs-skype-to-2.0.0.72.patch * nixpkgs-truecrypt-6.1a-fix.patch * nixpkgs-vxl-1.11.0-new.patch * nixpkgs-xkb-popular-esperanto-symbols.patch * nixpkgs-xorg-via-video-fix.patch svn path=/nixpkgs/trunk/; revision=13751
2009-01-12 21:12:07 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cryopid = callPackage ../os-specific/linux/cryopid { };
* Added cryopid (contributed by Marco Maggesi). svn path=/nixpkgs/trunk/; revision=13291
2008-11-14 12:34:18 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cryptsetup = callPackage ../os-specific/linux/cryptsetup { };
Adding LUKS cryptsetup for the devicemapper. svn path=/nixpkgs/trunk/; revision=14289
2009-03-01 11:11:21 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cramfsswap = callPackage ../os-specific/linux/cramfsswap { };
* Added `zapping', a TV viewer application. It depends on Gnome, so lots of packages are needed. svn path=/nixpkgs/trunk/; revision=681
2004-01-21 09:34:19 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
darwinArchUtility = callPackage ../os-specific/darwin/arch { };
* Refactoring: move most filesystem utilities / FUSE filesystems to tools/filesystems. Previously they were all over the place. svn path=/nixpkgs/trunk/; revision=18809
2009-12-04 15:39:49 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
darwinSwVersUtility = callPackage ../os-specific/darwin/sw_vers { };
* added davfs2 1.4.1 svn path=/nixpkgs/trunk/; revision=17345
2009-09-22 09:12:11 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
darwinLipoUtility = callPackage ../os-specific/darwin/lipo { };
pkgs/os-specific/darwin/lipo: add support for running the native Darwin lipo utility svn path=/nixpkgs/trunk/; revision=21426
2010-04-29 15:56:44 +01:00
* Updated LVM2 to 2.02.56. LVM2 now includes device-mapper, so that package is obsolete. Also install the udev rules. svn path=/nixpkgs/trunk/; revision=19293
2010-01-07 16:14:10 +00:00
devicemapper = lvm2;
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dmidecode = callPackage ../os-specific/linux/dmidecode { };
Added dmidecode and kqemu svn path=/nixpkgs/trunk/; revision=10098
2008-01-08 00:18:20 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dmtcp = callPackage ../os-specific/linux/dmtcp { };
Add new package pkgs/os-specific/linux/dmtcp/ svn path=/nixpkgs/trunk/; revision=19819
2010-02-04 15:41:45 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
dietlibc = callPackage ../os-specific/linux/dietlibc {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
# Dietlibc 0.30 doesn't compile on PPC with GCC 4.1, bus GCC 3.4 works.
* Dietlibc 0.31 svn path=/nixpkgs/branches/stdenv-updates/; revision=9770
2007-11-21 15:32:20 +00:00
stdenv = if stdenv.system == "powerpc-linux" then overrideGCC stdenv gcc34 else stdenv;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
Fix wxGTK reference for xchm svn path=/nixpkgs/trunk/; revision=18156
2009-11-05 21:08:53 +00:00
directvnc = builderDefsPackage ../os-specific/linux/directvnc {
inherit libjpeg pkgconfig zlib directfb;
inherit (xlibs) xproto;
};
Adding dmraid svn path=/nixpkgs/trunk/; revision=17292
2009-09-20 09:38:30 +01:00
dmraid = builderDefsPackage ../os-specific/linux/dmraid {
inherit devicemapper;
};
some more x86_64 darwin changes svn path=/nixpkgs/trunk/; revision=18774
2009-12-02 22:19:49 +00:00
libuuid = if ! stdenv.isDarwin then utillinuxng else null;
* Fixed ntfsprogs. svn path=/nixpkgs/trunk/; revision=14695
2009-03-25 10:55:28 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
e3cfsprogs = callPackage ../os-specific/linux/e3cfsprogs { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
eject = callPackage ../os-specific/linux/eject { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
Added FBTerm - framebuffer terminal emulator svn path=/nixpkgs/trunk/; revision=13596
2008-12-08 12:44:42 +00:00
fbterm = builderDefsPackage (import ../os-specific/linux/fbterm) {
Updating fbterm svn path=/nixpkgs/trunk/; revision=17981
2009-10-27 23:49:59 +00:00
inherit fontconfig gpm freetype pkgconfig ncurses;
Added FBTerm - framebuffer terminal emulator svn path=/nixpkgs/trunk/; revision=13596
2008-12-08 12:44:42 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
fuse = callPackage ../os-specific/linux/fuse { };
* Converted some more packages. * Subversion no longer needs libxml2 (just expat). svn path=/nixpkgs/trunk/; revision=478
2003-11-05 12:17:48 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
fxload = callPackage ../os-specific/linux/fxload { };
* Added fxload, a tool to upload firmware to Cypress EZ-USB microcontrollers. svn path=/nixpkgs/trunk/; revision=10483
2008-02-03 14:43:19 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gpm = callPackage ../servers/gpm {
LZMA support in builderDefs; gpm added svn path=/nixpkgs/trunk/; revision=11874
2008-05-21 14:27:41 +01:00
flex = flex2535;
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
LZMA support in builderDefs; gpm added svn path=/nixpkgs/trunk/; revision=11874
2008-05-21 14:27:41 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
hal = callPackage ../os-specific/linux/hal { };
exrviewer added (needs ctl openexr openexr_ctl) fltk update ilmbase updated ndiswrapper does compile but has to be integrated into the kernel somehow svn path=/nixpkgs/trunk/; revision=9863
2007-12-05 21:25:47 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
halevt = callPackage ../os-specific/linux/hal/hal-evt.nix { };
adding halevt svn path=/nixpkgs/trunk/; revision=17027
2009-09-10 17:57:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
hal_info = callPackage ../os-specific/linux/hal/info.nix { };
* Added hal-info. svn path=/nixpkgs/trunk/; revision=15385
2009-04-28 22:59:09 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
hal_info_synaptics = callPackage ../os-specific/linux/hal/synaptics.nix { };
A package to feed to HAL to get synaptics support svn path=/nixpkgs/trunk/; revision=18299
2009-11-08 22:12:55 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
hdparm = callPackage ../os-specific/linux/hdparm { };
Add `hibernate', an swsusp/Tux-on-Ice convenience script. svn path=/nixpkgs/trunk/; revision=11438
2008-04-01 15:02:54 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
hibernate = callPackage ../os-specific/linux/hibernate { };
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
htop = callPackage ../os-specific/linux/htop { };
* vlc and required packages. Finally a good DVD player :-) svn path=/nixpkgs/trunk/; revision=574
2003-12-03 21:58:16 +00:00
GNU Hurd: Add full cross build. svn path=/nixpkgs/trunk/; revision=21916
2010-05-20 12:54:40 +01:00
hurdCross = forceBuildDrv(import ../os-specific/gnu/hurd {
inherit fetchgit stdenv autoconf libtool texinfo machHeaders
mig glibcCross;
automake = automake111x;
headersOnly = false;
cross = assert crossSystem != null; crossSystem;
gccCross = gccCrossStageFinal;
});
GNU Hurd: Allow partial builds. svn path=/nixpkgs/trunk/; revision=21899
2010-05-19 22:28:34 +01:00
hurdCrossIntermediate = forceBuildDrv(import ../os-specific/gnu/hurd {
inherit fetchgit stdenv autoconf libtool texinfo machHeaders
mig glibcCross;
automake = automake111x;
headersOnly = false;
cross = assert crossSystem != null; crossSystem;
# The "final" GCC needs glibc and the Hurd libraries (libpthread in
# particular) so we first need an intermediate Hurd built with the
# intermediate GCC.
gccCross = gccCrossStageStatic;
# This intermediate Hurd is only needed to build libpthread, which really
# only needs libihash.
buildTarget = "libihash";
installTarget = "libihash-install";
});
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
hurdHeaders = callPackage ../os-specific/gnu/hurd {
Add GNU Hurd (headers). svn path=/nixpkgs/trunk/; revision=21751
2010-05-12 16:46:47 +01:00
automake = automake111x;
headersOnly = true;
* ltrace: updated to 0.5.3. * libdbi / libdbi-drivers: updated to 0.8.3, and make it compile with SQLite. * qemu-image: fix the URL. * gdmap: make it build again (requires an older GTK+). * rlwrap: updated to 0.37. * smbfs-fuse -> fusesmb to match the upstream name. * x11vnc: updated to 0.9.10. * clearlyU: fix the URL. * Various packages: follow the coding conventions. svn path=/nixpkgs/trunk/; revision=22814
2010-07-29 19:55:16 +01:00
gccCross = null;
glibcCross = null;
Add GNU Hurd (headers). svn path=/nixpkgs/trunk/; revision=21751
2010-05-12 16:46:47 +01:00
};
GNU Hurd: Add libpthread. svn path=/nixpkgs/trunk/; revision=21900
2010-05-19 22:28:57 +01:00
hurdLibpthreadCross = forceBuildDrv(import ../os-specific/gnu/libpthread {
inherit fetchgit stdenv autoconf automake libtool
machHeaders hurdHeaders glibcCross;
hurd = hurdCrossIntermediate;
gccCross = gccCrossStageStatic;
cross = assert crossSystem != null; 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 17:26:58 +01:00
hwdata = callPackage ../os-specific/linux/hwdata { };
Added qt-4 svn path=/nixpkgs/trunk/; revision=8991
2007-07-17 18:08:38 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ifplugd = callPackage ../os-specific/linux/ifplugd { };
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
iproute = callPackage ../os-specific/linux/iproute { };
* vlc and required packages. Finally a good DVD player :-) svn path=/nixpkgs/trunk/; revision=574
2003-12-03 21:58:16 +00:00
Trying to reinstate the meta-based Hydra builds svn path=/nixpkgs/trunk/; revision=16883
2009-08-28 07:29:21 +01:00
iputils = (
Attempt to mark up packages with platform assertions svn path=/nixpkgs/trunk/; revision=16850
2009-08-25 07:36:05 +01:00
import ../os-specific/linux/iputils {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit fetchurl stdenv;
glibc = stdenv.gcc.libc;
Replace `kernelHeaders' by `linuxHeaders'. svn path=/nixpkgs/branches/stdenv-updates/; revision=19067
2009-12-21 14:04:45 +00:00
linuxHeaders = stdenv.gcc.libc.kernelHeaders;
Attempt to mark up packages with platform assertions svn path=/nixpkgs/trunk/; revision=16850
2009-08-25 07:36:05 +01:00
});
Added redland library (also known as librdf) svn path=/nixpkgs/trunk/; revision=9390
2007-10-01 16:14:50 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
iptables = callPackage ../os-specific/linux/iptables { };
* vlc and required packages. Finally a good DVD player :-) svn path=/nixpkgs/trunk/; revision=574
2003-12-03 21:58:16 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ipw2200fw = callPackage ../os-specific/linux/firmware/ipw2200 { };
* vlc and required packages. Finally a good DVD player :-) svn path=/nixpkgs/trunk/; revision=574
2003-12-03 21:58:16 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
iwlwifi1000ucode = callPackage ../os-specific/linux/firmware/iwlwifi-1000-ucode { };
Add Firmware for the Intel 1000 wireless card. svn path=/nixpkgs/trunk/; revision=19132
2009-12-26 16:22:51 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
iwlwifi3945ucode = callPackage ../os-specific/linux/firmware/iwlwifi-3945-ucode { };
* Firmware for the Intel 3945ABG. svn path=/nixpkgs/trunk/; revision=10126
2008-01-12 22:38:37 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
iwlwifi4965ucodeV1 = callPackage ../os-specific/linux/firmware/iwlwifi-4965-ucode { };
Add Intel Wi-Fi firmware for kernels 2.6.27 and later; make `iwlwifi4965ucode' part of `kernelPackagesFor'. svn path=/nixpkgs/trunk/; revision=13429
2008-11-26 13:15:38 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
iwlwifi4965ucodeV2 = callPackage ../os-specific/linux/firmware/iwlwifi-4965-ucode/version-2.nix { };
Add Intel 4965 wireless firmware. svn path=/nixpkgs/trunk/; revision=10734
2008-02-18 16:15:51 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
iwlwifi5000ucode = callPackage ../os-specific/linux/firmware/iwlwifi-5000-ucode { };
* Firmware for the Intel 5000 wireless cards. svn path=/nixpkgs/trunk/; revision=15395
2009-04-29 15:50:59 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
kbd = callPackage ../os-specific/linux/kbd { };
Added pygame and some of its dependencies. Also added Python Imaging library. svn path=/nixpkgs/trunk/; revision=9082
2007-08-09 18:33:18 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libcroup = callPackage ../os-specific/linux/libcg { };
libcgroup: library that abstracts the control group file system in Linux. svn path=/nixpkgs/trunk/; revision=22548
2010-07-09 14:15:51 +01:00
* Revert to the Linux 2.6.28 headers because 2.6.32 gives more problems than it's worth (e.g. build failures in strace and klibc - see also http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=538372). svn path=/nixpkgs/branches/stdenv-updates/; revision=19562
2010-01-20 10:56:40 +00:00
linuxHeaders = linuxHeaders_2_6_28;
* Some VLC-related updates. * Variability :-) Provide both Autoconf 2.59 and 2.60 (the former being the default for now). svn path=/nixpkgs/trunk/; revision=5539
2006-06-29 13:41:25 +01:00
Adding linux 2.4 kernel headers for cross builds. (I'm thinking of OpenWRT machines out there, mips, with linux 2.4) svn path=/nixpkgs/trunk/; revision=20539
2010-03-10 20:44:48 +00:00
linuxHeaders26Cross = forceBuildDrv (import ../os-specific/linux/kernel-headers/2.6.32.nix {
I removed the function-shape of the cross-toolchain related attributes in the all-packages.nix. That was more complicating than helping. svn path=/nixpkgs/trunk/; revision=20457
2010-03-06 23:36:55 +00:00
inherit stdenv fetchurl perl;
Adding assertions for the cross-toolchain attributes, so noone feels tempted to build them without setting a crossSystem to build for. svn path=/nixpkgs/trunk/; revision=20459
2010-03-07 00:05:51 +00: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 19:51:45 +00: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 08:11:30 +00:00
Adding linux 2.4 kernel headers for cross builds. (I'm thinking of OpenWRT machines out there, mips, with linux 2.4) svn path=/nixpkgs/trunk/; revision=20539
2010-03-10 20:44:48 +00:00
linuxHeaders24Cross = forceBuildDrv (import ../os-specific/linux/kernel-headers/2.4.nix {
inherit stdenv fetchurl perl;
cross = assert crossSystem != null; crossSystem;
});
# 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 17:26:58 +01:00
linuxHeaders_2_6_18 = callPackage ../os-specific/linux/kernel-headers/2.6.18.5.nix { };
Fixed missing parameters for arb - and added kernelHeaders_2.6.18 svn path=/nixpkgs/trunk/; revision=12970
2008-10-06 14:18:02 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
linuxHeaders_2_6_28 = callPackage ../os-specific/linux/kernel-headers/2.6.28.nix { };
* KVM 82. * Kernel headers for Linux 2.6.28. svn path=/nixpkgs/trunk/; revision=13755
2009-01-13 12:40:58 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
linuxHeaders_2_6_32 = callPackage ../os-specific/linux/kernel-headers/2.6.32.nix { };
* Use the Linux 2.6.32 kernel headers. svn path=/nixpkgs/branches/stdenv-updates/; revision=19552
2010-01-19 18:02:37 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
kernelPatches = callPackage ../os-specific/linux/kernel/patches.nix { };
* Use the generic kernel builder. svn path=/nixpkgs/trunk/; revision=13779
2009-01-15 15:54:24 +00:00
Rename `kernel*' to `linux*'. svn path=/nixpkgs/branches/stdenv-updates/; revision=19068
2009-12-21 14:12:00 +00:00
linux_2_6_25 = makeOverridable (import ../os-specific/linux/kernel/linux-2.6.25.nix) {
* Linux 2.6.26.2. Totally untested of course. svn path=/nixpkgs/trunk/; revision=12534
2008-08-07 15:57:10 +01:00
inherit fetchurl stdenv perl mktemp module_init_tools;
* Use the kernel config generator for Linux 2.6.25. svn path=/nixpkgs/branches/kernel-config/; revision=18948
2009-12-14 19:08:20 +00:00
kernelPatches =
[ kernelPatches.fbcondecor_2_6_25
kernelPatches.sec_perm_2_6_24
];
Trying to reinstate the meta-based Hydra builds svn path=/nixpkgs/trunk/; revision=16883
2009-08-28 07:29:21 +01:00
};
* Linux 2.6.26.2. Totally untested of course. svn path=/nixpkgs/trunk/; revision=12534
2008-08-07 15:57:10 +01:00
Rename `kernel*' to `linux*'. svn path=/nixpkgs/branches/stdenv-updates/; revision=19068
2009-12-21 14:12:00 +00:00
linux_2_6_27 = makeOverridable (import ../os-specific/linux/kernel/linux-2.6.27.nix) {
* Linux 2.6.27.4. Not tested yet. svn path=/nixpkgs/trunk/; revision=13144
2008-10-29 12:34:54 +00:00
inherit fetchurl stdenv perl mktemp module_init_tools;
* Use the kernel config generator for Linux 2.6.27. * Move kernel patches out of all-packages.nix to os-specific/linux/kernel/patches.nix. * Make the kernel config available under $out/config (it's also in $out/lib/modules/$version/build/.config, but that's kind of hard to find). svn path=/nixpkgs/branches/kernel-config/; revision=18937
2009-12-14 15:28:55 +00:00
kernelPatches =
[ kernelPatches.fbcondecor_2_6_27
kernelPatches.sec_perm_2_6_24
];
Trying to reinstate the meta-based Hydra builds svn path=/nixpkgs/trunk/; revision=16883
2009-08-28 07:29:21 +01:00
};
* Linux 2.6.27.4. Not tested yet. svn path=/nixpkgs/trunk/; revision=13144
2008-10-29 12:34:54 +00:00
Rename `kernel*' to `linux*'. svn path=/nixpkgs/branches/stdenv-updates/; revision=19068
2009-12-21 14:12:00 +00:00
linux_2_6_28 = makeOverridable (import ../os-specific/linux/kernel/linux-2.6.28.nix) {
* Linux 2.6.28. svn path=/nixpkgs/trunk/; revision=13743
2009-01-12 13:11:18 +00:00
inherit fetchurl stdenv perl mktemp module_init_tools;
* Use the kernel config generator for Linux 2.6.27. * Move kernel patches out of all-packages.nix to os-specific/linux/kernel/patches.nix. * Make the kernel config available under $out/config (it's also in $out/lib/modules/$version/build/.config, but that's kind of hard to find). svn path=/nixpkgs/branches/kernel-config/; revision=18937
2009-12-14 15:28:55 +00:00
kernelPatches =
[ kernelPatches.fbcondecor_2_6_28
kernelPatches.sec_perm_2_6_24
* Use the kernel config generator for Linux 2.6.28. * Get rid of Linux 2.6.20 and 2.6.26 (the former was only used for building UML). svn path=/nixpkgs/branches/kernel-config/; revision=18945
2009-12-14 18:34:46 +00:00
kernelPatches.ext4_softlockups_2_6_28
* Use the kernel config generator for Linux 2.6.27. * Move kernel patches out of all-packages.nix to os-specific/linux/kernel/patches.nix. * Make the kernel config available under $out/config (it's also in $out/lib/modules/$version/build/.config, but that's kind of hard to find). svn path=/nixpkgs/branches/kernel-config/; revision=18937
2009-12-14 15:28:55 +00:00
];
* addCoverageInstrumentation: factor out the code that keeps the build tree under $out into a separate stdenv adapter named keepBuildTree. * makeModulesClosure: support building an initrd for a kernel that has been compiled with coverage instrumentation. svn path=/nixpkgs/trunk/; revision=16916
2009-09-01 22:56:46 +01:00
};
* Linux 2.6.28. svn path=/nixpkgs/trunk/; revision=13743
2009-01-12 13:11:18 +00:00
Rename `kernel*' to `linux*'. svn path=/nixpkgs/branches/stdenv-updates/; revision=19068
2009-12-21 14:12:00 +00:00
linux_2_6_29 = makeOverridable (import ../os-specific/linux/kernel/linux-2.6.29.nix) {
* Linux 2.6.29. It doesn't build yet due to some depmod problem. svn path=/nixpkgs/trunk/; revision=15884
2009-06-07 00:09:38 +01:00
inherit fetchurl stdenv perl mktemp module_init_tools;
* Use the kernel config generator for Linux 2.6.27. * Move kernel patches out of all-packages.nix to os-specific/linux/kernel/patches.nix. * Make the kernel config available under $out/config (it's also in $out/lib/modules/$version/build/.config, but that's kind of hard to find). svn path=/nixpkgs/branches/kernel-config/; revision=18937
2009-12-14 15:28:55 +00:00
kernelPatches =
[ kernelPatches.fbcondecor_2_6_29
kernelPatches.sec_perm_2_6_24
];
* Deleted some obsolete kernels (2.6.20, 2.6.21, 2.6.22, 2.6.23 and the 2.6.31rcs). svn path=/nixpkgs/trunk/; revision=18065
2009-11-01 17:17:40 +00:00
};
* Linux 2.6.29. It doesn't build yet due to some depmod problem. svn path=/nixpkgs/trunk/; revision=15884
2009-06-07 00:09:38 +01:00
Rename `kernel*' to `linux*'. svn path=/nixpkgs/branches/stdenv-updates/; revision=19068
2009-12-21 14:12:00 +00:00
linux_2_6_31 = makeOverridable (import ../os-specific/linux/kernel/linux-2.6.31.nix) {
Porting changes from stdenv-updates into this branch. This comes from: svn diff ^/nixpkgs/trunk/@18255 ^/nixpkgs/branches/stdenv-updates/ > diff patch -p0 < diff and then adding into svn all files new from the patch. trunk@18255 comes from the last time I updated stdenv-updates from trunk. svn path=/nixpkgs/stdenv-updates2/; revision=18272
2009-11-08 00:32:12 +00:00
inherit fetchurl stdenv perl mktemp module_init_tools platform;
Adding 2.6.31 kernel and trying to generate config for it without manual operations svn path=/nixpkgs/trunk/; revision=17065
2009-09-12 08:13:20 +01:00
kernelPatches = [];
};
Merging from trunk. I fixed conflicts regarding the renaming 'kernel' -> 'linux' in all-packages. Also a small conflict in all-packages about making openssl overridable. And I some linux 2.6.31-zen kernel files also marked in conflict. svn path=/nixpkgs/branches/stdenv-updates/; revision=19438
2010-01-14 14:49:31 +00: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 17:35:47 +00:00
inherit fetchurl stdenv perl mktemp module_init_tools ubootChooser;
* Use the kernel config generator for Linux 2.6.27. * Move kernel patches out of all-packages.nix to os-specific/linux/kernel/patches.nix. * Make the kernel config available under $out/config (it's also in $out/lib/modules/$version/build/.config, but that's kind of hard to find). svn path=/nixpkgs/branches/kernel-config/; revision=18937
2009-12-14 15:28:55 +00:00
kernelPatches =
[ kernelPatches.fbcondecor_2_6_31
kernelPatches.sec_perm_2_6_24
* Get aufs2 and aufs2-util to build against Linux 2.6.32. svn path=/nixpkgs/trunk/; revision=22032
2010-05-28 08:09:15 +01:00
kernelPatches.aufs2_2_6_32
* Apply a patch that is apparently required to make the kernel work properly on Amazon EC2. * Always apply the CIFS timeout patch. It's rather annoying to have to build a separate kernel for the VM tests. svn path=/nixpkgs/trunk/; revision=22630
2010-07-18 22:10:46 +01:00
kernelPatches.cifs_timeout
kernelPatches.no_xsave
* Ensure that the dell-bluetooth device does not stay in the "hard blocked" state. svn path=/nixpkgs/branches/x-updates/; revision=22730
2010-07-25 13:15:59 +01:00
kernelPatches.dell_rfkill
* Use the kernel config generator for Linux 2.6.27. * Move kernel patches out of all-packages.nix to os-specific/linux/kernel/patches.nix. * Make the kernel config available under $out/config (it's also in $out/lib/modules/$version/build/.config, but that's kind of hard to find). svn path=/nixpkgs/branches/kernel-config/; revision=18937
2009-12-14 15:28:55 +00:00
];
Trying to add Zen Linux Kernel svn path=/nixpkgs/trunk/; revision=17050
2009-09-11 14:16:18 +01:00
};
Add a Linux kernel suitable for SystemTap. svn path=/nixpkgs/trunk/; revision=21618
2010-05-05 20:48:46 +01: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;
systemtap = true;
Don't strip Linux modules in the SystemTap variant. svn path=/nixpkgs/trunk/; revision=21619
2010-05-05 20:48:52 +01:00
dontStrip = true;
Add a Linux kernel suitable for SystemTap. svn path=/nixpkgs/trunk/; revision=21618
2010-05-05 20:48:46 +01:00
kernelPatches =
[ kernelPatches.fbcondecor_2_6_31
kernelPatches.sec_perm_2_6_24
kernelPatches.tracehook_2_6_32
kernelPatches.utrace_2_6_32
];
};
Merging from trunk. I fixed conflicts regarding the renaming 'kernel' -> 'linux' in all-packages. Also a small conflict in all-packages about making openssl overridable. And I some linux 2.6.31-zen kernel files also marked in conflict. svn path=/nixpkgs/branches/stdenv-updates/; revision=19438
2010-01-14 14:49:31 +00:00
linux_2_6_32_zen4 = makeOverridable (import ../os-specific/linux/zen-kernel/2.6.32-zen4.nix) {
Update Zen kernel set svn path=/nixpkgs/trunk/; revision=19404
2010-01-13 15:46:38 +00:00
inherit fetchurl stdenv perl mktemp module_init_tools runCommand xz;
Update Zen Kernel svn path=/nixpkgs/trunk/; revision=18174
2009-11-05 23:32:48 +00:00
};
Merging from trunk. I fixed conflicts regarding the renaming 'kernel' -> 'linux' in all-packages. Also a small conflict in all-packages about making openssl overridable. And I some linux 2.6.31-zen kernel files also marked in conflict. svn path=/nixpkgs/branches/stdenv-updates/; revision=19438
2010-01-14 14:49:31 +00:00
linux_2_6_32_zen4_oldi686 = linux_2_6_32_zen4.override {
Update Zen kernel set svn path=/nixpkgs/trunk/; revision=19404
2010-01-13 15:46:38 +00:00
features = {
oldI686 = true;
};
Update Zen Kernel svn path=/nixpkgs/trunk/; revision=18174
2009-11-05 23:32:48 +00:00
};
Merging from trunk. I fixed conflicts regarding the renaming 'kernel' -> 'linux' in all-packages. Also a small conflict in all-packages about making openssl overridable. And I some linux 2.6.31-zen kernel files also marked in conflict. svn path=/nixpkgs/branches/stdenv-updates/; revision=19438
2010-01-14 14:49:31 +00:00
linux_2_6_32_zen4_bfs = linux_2_6_32_zen4.override {
Update Zen kernel set svn path=/nixpkgs/trunk/; revision=19404
2010-01-13 15:46:38 +00:00
features = {
ckSched = true;
};
* Linux 2.6.32. svn path=/nixpkgs/branches/kernel-config/; revision=18932
2009-12-14 10:15:52 +00:00
};
* Linux 2.6.33. svn path=/nixpkgs/trunk/; revision=20246
2010-02-25 12:40:03 +00:00
linux_2_6_33 = makeOverridable (import ../os-specific/linux/kernel/linux-2.6.33.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 17:35:47 +00:00
inherit fetchurl stdenv perl mktemp module_init_tools ubootChooser;
* Linux 2.6.33. svn path=/nixpkgs/trunk/; revision=20246
2010-02-25 12:40:03 +00:00
kernelPatches =
* Updated fbcondecor for Linux 2.6.33. svn path=/nixpkgs/trunk/; revision=20257
2010-02-25 14:15:42 +00:00
[ kernelPatches.fbcondecor_2_6_33
* Linux 2.6.33. svn path=/nixpkgs/trunk/; revision=20246
2010-02-25 12:40:03 +00:00
kernelPatches.sec_perm_2_6_24
];
};
Add 2.6.33-zen1 kernels svn path=/nixpkgs/trunk/; revision=20676
2010-03-17 06:42:21 +00:00
linux_2_6_33_zen1 = makeOverridable (import ../os-specific/linux/zen-kernel/2.6.33-zen1.nix) {
inherit fetchurl stdenv perl mktemp module_init_tools runCommand xz;
};
linux_2_6_33_zen1_oldi686 = linux_2_6_33_zen1.override {
features = {
oldI686 = true;
};
};
linux_2_6_33_zen1_bfs = linux_2_6_33_zen1.override {
features = {
ckSched = true;
};
};
kernel-2.6.34 The Linux 2.6.34 kernel delivers (from [1]) - many open-source GPU driver updates, - GPU switching support, - the LogFS file-system, - faster KVM networking support, - Btrfs file-system updates, - the VMware memory ballooning driver, - and many other changes. A more exhaustive list of the Linux 2.6.34 kernel changes from architectures to network drivers is listed on the Wiki at KernelNewbies.org.[2] [1] http://www.phoronix.com: [2] http://kernelnewbies.org/Linux_2_6_34 svn path=/nixpkgs/trunk/; revision=22023
2010-05-27 20:44:23 +01:00
linux_2_6_34 = makeOverridable (import ../os-specific/linux/kernel/linux-2.6.34.nix) {
inherit fetchurl stdenv perl mktemp module_init_tools ubootChooser;
kernelPatches =
[ /*kernelPatches.fbcondecor_2_6_33*/
kernelPatches.sec_perm_2_6_24
aufs2: patch for kernel 2.6.34 svn path=/nixpkgs/trunk/; revision=22178
2010-06-08 07:29:02 +01:00
kernelPatches.aufs2_2_6_34
kernel-2.6.34 The Linux 2.6.34 kernel delivers (from [1]) - many open-source GPU driver updates, - GPU switching support, - the LogFS file-system, - faster KVM networking support, - Btrfs file-system updates, - the VMware memory ballooning driver, - and many other changes. A more exhaustive list of the Linux 2.6.34 kernel changes from architectures to network drivers is listed on the Wiki at KernelNewbies.org.[2] [1] http://www.phoronix.com: [2] http://kernelnewbies.org/Linux_2_6_34 svn path=/nixpkgs/trunk/; revision=22023
2010-05-27 20:44:23 +01:00
];
};
kernel updates and add kernel 2.6.35.1 svn path=/nixpkgs/trunk/; revision=23155
2010-08-12 17:33:19 +01: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 =
[ /*kernelPatches.fbcondecor_2_6_33*/
kernelPatches.sec_perm_2_6_24
];
};
Fix stupid typo in linux_2_6_35_oldI686 definition svn path=/nixpkgs/trunk/; revision=23174
2010-08-14 18:13:42 +01:00
linux_2_6_35_oldI686 = linux_2_6_35.override {
Add latest Linux kernel for real i686 platform, not modern amd64-in-32bit-mode svn path=/nixpkgs/trunk/; revision=23173
2010-08-14 17:04:02 +01:00
extraConfig = ''
HIGHMEM64G? n
XEN? n
'';
extraMeta = {
platforms = ["i686-linux"];
Fix stupid typo in linux_2_6_35_oldI686 definition svn path=/nixpkgs/trunk/; revision=23174
2010-08-14 18:13:42 +01:00
maintainers = [lib.maintainers.raskin];
Add latest Linux kernel for real i686 platform, not modern amd64-in-32bit-mode svn path=/nixpkgs/trunk/; revision=23173
2010-08-14 17:04:02 +01:00
};
};
Rename `kernel*' to `linux*'. svn path=/nixpkgs/branches/stdenv-updates/; revision=19068
2009-12-21 14:12:00 +00:00
/* Linux kernel modules are inherently tied to a specific kernel. So
* Put all packages that depend on a specific kernel (notably kernel modules) together in an attribute set returned by the function "kernelPackagesFor" that takes a kernel as argument. For instance, kernelPackages_2_6_23 is the result of calling this function with kernel_2_6_23. This is necessary in NixOS to make it easier to override the kernel: it's not enough to just specify a different kernel (via the boot.kernel option), but you also need matching nvidiaDriver, aufs, iwlwifi, etc. Having a single attribute set that contains all kernel-related packages makes this much easier. * The kernel now has a passthru attribute "features" that allows NixOS expressions to test whether a kernel has certain features. For instance, the externel "iwlwifi" kernel module package should only be built on kernels < 2.6.24, as kernels >= 2.6.24 have iwlwifi support integrated. So the NixOS expressions can do the test "kernel.features ? iwlwifi" to see if the iwlwifi package should be built. Kernel patches can declare additional features. E.g., the fbsplash patch adds a "fbSplash" feature. svn path=/nixpkgs/trunk/; revision=11881
2008-05-22 13:01:24 +01: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. */
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01:00
linuxPackagesFor = kernel: self: let callPackage = newScope self; in rec {
* Put all packages that depend on a specific kernel (notably kernel modules) together in an attribute set returned by the function "kernelPackagesFor" that takes a kernel as argument. For instance, kernelPackages_2_6_23 is the result of calling this function with kernel_2_6_23. This is necessary in NixOS to make it easier to override the kernel: it's not enough to just specify a different kernel (via the boot.kernel option), but you also need matching nvidiaDriver, aufs, iwlwifi, etc. Having a single attribute set that contains all kernel-related packages makes this much easier. * The kernel now has a passthru attribute "features" that allows NixOS expressions to test whether a kernel has certain features. For instance, the externel "iwlwifi" kernel module package should only be built on kernels < 2.6.24, as kernels >= 2.6.24 have iwlwifi support integrated. So the NixOS expressions can do the test "kernel.features ? iwlwifi" to see if the iwlwifi package should be built. Kernel patches can declare additional features. E.g., the fbsplash patch adds a "fbSplash" feature. svn path=/nixpkgs/trunk/; revision=11881
2008-05-22 13:01:24 +01:00
inherit kernel;
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ati_drivers_x11 = callPackage ../os-specific/linux/ati-drivers { };
adding ati-drivers There is still much to be done, see http://thread.gmane.org/gmane.linux.distributions.nixos/4145 svn path=/nixpkgs/trunk/; revision=21848
2010-05-18 20:36:55 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
aufs = callPackage ../os-specific/linux/aufs { };
* Put all packages that depend on a specific kernel (notably kernel modules) together in an attribute set returned by the function "kernelPackagesFor" that takes a kernel as argument. For instance, kernelPackages_2_6_23 is the result of calling this function with kernel_2_6_23. This is necessary in NixOS to make it easier to override the kernel: it's not enough to just specify a different kernel (via the boot.kernel option), but you also need matching nvidiaDriver, aufs, iwlwifi, etc. Having a single attribute set that contains all kernel-related packages makes this much easier. * The kernel now has a passthru attribute "features" that allows NixOS expressions to test whether a kernel has certain features. For instance, the externel "iwlwifi" kernel module package should only be built on kernels < 2.6.24, as kernels >= 2.6.24 have iwlwifi support integrated. So the NixOS expressions can do the test "kernel.features ? iwlwifi" to see if the iwlwifi package should be built. Kernel patches can declare additional features. E.g., the fbsplash patch adds a "fbSplash" feature. svn path=/nixpkgs/trunk/; revision=11881
2008-05-22 13:01:24 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
aufs2 = callPackage ../os-specific/linux/aufs2 { };
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
aufs2_util = callPackage ../os-specific/linux/aufs2-util { };
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
blcr = callPackage ../os-specific/linux/blcr/0.8.2.nix {
libtool = libtool_1_5; # libtool 2 causes a fork bomb
pkgs/os-specific/linux/blcr: update to version 0.8.2 svn path=/nixpkgs/trunk/; revision=21091
2010-04-15 13:08:08 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
exmap = callPackage ../os-specific/linux/exmap {
Add Exmap, a Linux-specific tool to examine process memory usage. svn path=/nixpkgs/trunk/; revision=12857
2008-09-12 21:00:00 +01:00
inherit (gtkLibs) 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 17:26:58 +01:00
iwlwifi = callPackage ../os-specific/linux/iwlwifi { };
* Put all packages that depend on a specific kernel (notably kernel modules) together in an attribute set returned by the function "kernelPackagesFor" that takes a kernel as argument. For instance, kernelPackages_2_6_23 is the result of calling this function with kernel_2_6_23. This is necessary in NixOS to make it easier to override the kernel: it's not enough to just specify a different kernel (via the boot.kernel option), but you also need matching nvidiaDriver, aufs, iwlwifi, etc. Having a single attribute set that contains all kernel-related packages makes this much easier. * The kernel now has a passthru attribute "features" that allows NixOS expressions to test whether a kernel has certain features. For instance, the externel "iwlwifi" kernel module package should only be built on kernels < 2.6.24, as kernels >= 2.6.24 have iwlwifi support integrated. So the NixOS expressions can do the test "kernel.features ? iwlwifi" to see if the iwlwifi package should be built. Kernel patches can declare additional features. E.g., the fbsplash patch adds a "fbSplash" feature. svn path=/nixpkgs/trunk/; revision=11881
2008-05-22 13:01:24 +01:00
Add Intel Wi-Fi firmware for kernels 2.6.27 and later; make `iwlwifi4965ucode' part of `kernelPackagesFor'. svn path=/nixpkgs/trunk/; revision=13429
2008-11-26 13:15:38 +00: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 17:26:58 +01:00
atheros = callPackage ../os-specific/linux/atheros/0.9.4.nix { };
Packages changes, needed after recent kernel expression restructurisation svn path=/nixpkgs/trunk/; revision=11883
2008-05-22 20:29:23 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
nvidia_x11 = callPackage ../os-specific/linux/nvidia-x11 { };
* Put all packages that depend on a specific kernel (notably kernel modules) together in an attribute set returned by the function "kernelPackagesFor" that takes a kernel as argument. For instance, kernelPackages_2_6_23 is the result of calling this function with kernel_2_6_23. This is necessary in NixOS to make it easier to override the kernel: it's not enough to just specify a different kernel (via the boot.kernel option), but you also need matching nvidiaDriver, aufs, iwlwifi, etc. Having a single attribute set that contains all kernel-related packages makes this much easier. * The kernel now has a passthru attribute "features" that allows NixOS expressions to test whether a kernel has certain features. For instance, the externel "iwlwifi" kernel module package should only be built on kernels < 2.6.24, as kernels >= 2.6.24 have iwlwifi support integrated. So the NixOS expressions can do the test "kernel.features ? iwlwifi" to see if the iwlwifi package should be built. Kernel patches can declare additional features. E.g., the fbsplash patch adds a "fbSplash" feature. svn path=/nixpkgs/trunk/; revision=11881
2008-05-22 13:01:24 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
nvidia_x11_legacy = callPackage ../os-specific/linux/nvidia-x11/legacy.nix { };
Adding the nvidia legacy drivers (I still use a geForce 4 AGP) svn path=/nixpkgs/trunk/; revision=17284
2009-09-19 23:09:08 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
openafsClient = callPackage ../servers/openafs-client { };
Fix bugs and improve pkgs/servers/openafs-client svn path=/nixpkgs/trunk/; revision=19750
2010-02-01 16:27:35 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
wis_go7007 = callPackage ../os-specific/linux/wis-go7007 { };
* Put all packages that depend on a specific kernel (notably kernel modules) together in an attribute set returned by the function "kernelPackagesFor" that takes a kernel as argument. For instance, kernelPackages_2_6_23 is the result of calling this function with kernel_2_6_23. This is necessary in NixOS to make it easier to override the kernel: it's not enough to just specify a different kernel (via the boot.kernel option), but you also need matching nvidiaDriver, aufs, iwlwifi, etc. Having a single attribute set that contains all kernel-related packages makes this much easier. * The kernel now has a passthru attribute "features" that allows NixOS expressions to test whether a kernel has certain features. For instance, the externel "iwlwifi" kernel module package should only be built on kernels < 2.6.24, as kernels >= 2.6.24 have iwlwifi support integrated. So the NixOS expressions can do the test "kernel.features ? iwlwifi" to see if the iwlwifi package should be built. Kernel patches can declare additional features. E.g., the fbsplash patch adds a "fbSplash" feature. svn path=/nixpkgs/trunk/; revision=11881
2008-05-22 13:01:24 +01:00
Fix the cleanup-induced problems svn path=/nixpkgs/trunk/; revision=18554
2009-11-23 12:21:34 +00:00
kqemu = builderDefsPackage ../os-specific/linux/kqemu/1.4.0pre1.nix {
inherit kernel perl;
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
Packages changes, needed after recent kernel expression restructurisation svn path=/nixpkgs/trunk/; revision=11883
2008-05-22 20:29:23 +01:00
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
splashutils =
* Removed splashutils 1.3 (obsolete). svn path=/nixpkgs/branches/stdenv-updates/; revision=19710
2010-01-27 14:35:38 +00:00
if kernel.features ? fbConDecor then pkgs.splashutils else null;
* splashutils 1.5.4.1, needed for kernels that have the new fbcondecor patch. splashutils 1.3 is retained for kernels with the fbsplash patch. svn path=/nixpkgs/trunk/; revision=12029
2008-06-10 17:09:53 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
ext3cowtools = callPackage ../os-specific/linux/ext3cow-tools {
* Put all packages that depend on a specific kernel (notably kernel modules) together in an attribute set returned by the function "kernelPackagesFor" that takes a kernel as argument. For instance, kernelPackages_2_6_23 is the result of calling this function with kernel_2_6_23. This is necessary in NixOS to make it easier to override the kernel: it's not enough to just specify a different kernel (via the boot.kernel option), but you also need matching nvidiaDriver, aufs, iwlwifi, etc. Having a single attribute set that contains all kernel-related packages makes this much easier. * The kernel now has a passthru attribute "features" that allows NixOS expressions to test whether a kernel has certain features. For instance, the externel "iwlwifi" kernel module package should only be built on kernels < 2.6.24, as kernels >= 2.6.24 have iwlwifi support integrated. So the NixOS expressions can do the test "kernel.features ? iwlwifi" to see if the iwlwifi package should be built. Kernel patches can declare additional features. E.g., the fbsplash patch adds a "fbSplash" feature. svn path=/nixpkgs/trunk/; revision=11881
2008-05-22 13:01:24 +01:00
kernel_ext3cowpatched = kernel;
};
Uncommented ndiswrapper svn path=/nixpkgs/trunk/; revision=12096
2008-06-15 12:39:54 +01: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 17:26:58 +01:00
ndiswrapper = callPackage ../os-specific/linux/ndiswrapper { };
Uncommented ndiswrapper svn path=/nixpkgs/trunk/; revision=12096
2008-06-15 12:39:54 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
ov511 = callPackage ../os-specific/linux/ov511 {
* Put all packages that depend on a specific kernel (notably kernel modules) together in an attribute set returned by the function "kernelPackagesFor" that takes a kernel as argument. For instance, kernelPackages_2_6_23 is the result of calling this function with kernel_2_6_23. This is necessary in NixOS to make it easier to override the kernel: it's not enough to just specify a different kernel (via the boot.kernel option), but you also need matching nvidiaDriver, aufs, iwlwifi, etc. Having a single attribute set that contains all kernel-related packages makes this much easier. * The kernel now has a passthru attribute "features" that allows NixOS expressions to test whether a kernel has certain features. For instance, the externel "iwlwifi" kernel module package should only be built on kernels < 2.6.24, as kernels >= 2.6.24 have iwlwifi support integrated. So the NixOS expressions can do the test "kernel.features ? iwlwifi" to see if the iwlwifi package should be built. Kernel patches can declare additional features. E.g., the fbsplash patch adds a "fbSplash" feature. svn path=/nixpkgs/trunk/; revision=11881
2008-05-22 13:01:24 +01:00
stdenv = overrideGCC stdenv gcc34;
};
# State Nix
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
snix = callPackage ../tools/package-management/snix {
* Put all packages that depend on a specific kernel (notably kernel modules) together in an attribute set returned by the function "kernelPackagesFor" that takes a kernel as argument. For instance, kernelPackages_2_6_23 is the result of calling this function with kernel_2_6_23. This is necessary in NixOS to make it easier to override the kernel: it's not enough to just specify a different kernel (via the boot.kernel option), but you also need matching nvidiaDriver, aufs, iwlwifi, etc. Having a single attribute set that contains all kernel-related packages makes this much easier. * The kernel now has a passthru attribute "features" that allows NixOS expressions to test whether a kernel has certain features. For instance, the externel "iwlwifi" kernel module package should only be built on kernels < 2.6.24, as kernels >= 2.6.24 have iwlwifi support integrated. So the NixOS expressions can do the test "kernel.features ? iwlwifi" to see if the iwlwifi package should be built. Kernel patches can declare additional features. E.g., the fbsplash patch adds a "fbSplash" feature. svn path=/nixpkgs/trunk/; revision=11881
2008-05-22 13:01:24 +01:00
Updating nix's aterm from aterm242fixes to aterm25 (proposed by niksnut). svn path=/nixpkgs/branches/stdenv-updates/; revision=18879
2009-12-10 14:50:50 +00:00
aterm = aterm25;
* Put all packages that depend on a specific kernel (notably kernel modules) together in an attribute set returned by the function "kernelPackagesFor" that takes a kernel as argument. For instance, kernelPackages_2_6_23 is the result of calling this function with kernel_2_6_23. This is necessary in NixOS to make it easier to override the kernel: it's not enough to just specify a different kernel (via the boot.kernel option), but you also need matching nvidiaDriver, aufs, iwlwifi, etc. Having a single attribute set that contains all kernel-related packages makes this much easier. * The kernel now has a passthru attribute "features" that allows NixOS expressions to test whether a kernel has certain features. For instance, the externel "iwlwifi" kernel module package should only be built on kernels < 2.6.24, as kernels >= 2.6.24 have iwlwifi support integrated. So the NixOS expressions can do the test "kernel.features ? iwlwifi" to see if the iwlwifi package should be built. Kernel patches can declare additional features. E.g., the fbsplash patch adds a "fbSplash" feature. svn path=/nixpkgs/trunk/; revision=11881
2008-05-22 13:01:24 +01:00
db4 = db45;
flex = flex2533;
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ext3cow_kernel = kernel; };
* Put all packages that depend on a specific kernel (notably kernel modules) together in an attribute set returned by the function "kernelPackagesFor" that takes a kernel as argument. For instance, kernelPackages_2_6_23 is the result of calling this function with kernel_2_6_23. This is necessary in NixOS to make it easier to override the kernel: it's not enough to just specify a different kernel (via the boot.kernel option), but you also need matching nvidiaDriver, aufs, iwlwifi, etc. Having a single attribute set that contains all kernel-related packages makes this much easier. * The kernel now has a passthru attribute "features" that allows NixOS expressions to test whether a kernel has certain features. For instance, the externel "iwlwifi" kernel module package should only be built on kernels < 2.6.24, as kernels >= 2.6.24 have iwlwifi support integrated. So the NixOS expressions can do the test "kernel.features ? iwlwifi" to see if the iwlwifi package should be built. Kernel patches can declare additional features. E.g., the fbsplash patch adds a "fbSplash" feature. svn path=/nixpkgs/trunk/; revision=11881
2008-05-22 13:01:24 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
sysprof = callPackage ../development/tools/profiling/sysprof {
Move `sysprof' to `kernelPackages'. Warning: it builds with 2.6.23 but not with 2.6.26. svn path=/nixpkgs/trunk/; revision=12803
2008-09-05 08:26:37 +01:00
inherit (gnome) gtk glib pango libglade;
};
First steps trying to build VirtualBox. I haven't finished. I left before trying to install and run the files compiled. svn path=/nixpkgs/trunk/; revision=13863
2009-01-25 20:09:17 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
systemtap = callPackage ../development/tools/profiling/systemtap {
Add SystemTap. svn path=/nixpkgs/trunk/; revision=21596
2010-05-04 14:32:09 +01:00
linux = kernel;
inherit (gnome) gtkmm libglademm;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
virtualbox = callPackage ../applications/virtualization/virtualbox {
Enabled 32 bit stdenv for virtualbox svn path=/nixpkgs/trunk/; revision=15064
2009-04-15 13:37:57 +01:00
stdenv = stdenv_32bit;
First steps trying to build VirtualBox. I haven't finished. I left before trying to install and run the files compiled. svn path=/nixpkgs/trunk/; revision=13863
2009-01-25 20:09:17 +00:00
inherit (gnome) libIDL;
};
pkgs/tools/typesetting/asciidoc: updated to version 8.5.1 New asciidoc versions do have a proper configure script. Using that simplifies the build instructions a bit. svn path=/nixpkgs/trunk/; revision=18076
2009-11-03 15:57:22 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
virtualboxGuestAdditions = callPackage ../applications/virtualization/virtualbox/guest-additions { };
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01:00
};
* Put all packages that depend on a specific kernel (notably kernel modules) together in an attribute set returned by the function "kernelPackagesFor" that takes a kernel as argument. For instance, kernelPackages_2_6_23 is the result of calling this function with kernel_2_6_23. This is necessary in NixOS to make it easier to override the kernel: it's not enough to just specify a different kernel (via the boot.kernel option), but you also need matching nvidiaDriver, aufs, iwlwifi, etc. Having a single attribute set that contains all kernel-related packages makes this much easier. * The kernel now has a passthru attribute "features" that allows NixOS expressions to test whether a kernel has certain features. For instance, the externel "iwlwifi" kernel module package should only be built on kernels < 2.6.24, as kernels >= 2.6.24 have iwlwifi support integrated. So the NixOS expressions can do the test "kernel.features ? iwlwifi" to see if the iwlwifi package should be built. Kernel patches can declare additional features. E.g., the fbsplash patch adds a "fbSplash" feature. svn path=/nixpkgs/trunk/; revision=11881
2008-05-22 13:01:24 +01:00
# Build the kernel modules for the some of the kernels.
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01:00
linuxPackages_2_6_25 = recurseIntoAttrs (linuxPackagesFor linux_2_6_25 pkgs.linuxPackages_2_6_25);
linuxPackages_2_6_27 = recurseIntoAttrs (linuxPackagesFor linux_2_6_27 pkgs.linuxPackages_2_6_27);
linuxPackages_2_6_28 = recurseIntoAttrs (linuxPackagesFor linux_2_6_28 pkgs.linuxPackages_2_6_28);
linuxPackages_2_6_29 = recurseIntoAttrs (linuxPackagesFor linux_2_6_29 pkgs.linuxPackages_2_6_29);
linuxPackages_2_6_31 = recurseIntoAttrs (linuxPackagesFor linux_2_6_31 pkgs.linuxPackages_2_6_31);
linuxPackages_2_6_32 = recurseIntoAttrs (linuxPackagesFor linux_2_6_32 pkgs.linuxPackages_2_6_32);
Add a Linux kernel suitable for SystemTap. svn path=/nixpkgs/trunk/; revision=21618
2010-05-05 20:48:46 +01:00
linuxPackages_2_6_32_systemtap =
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01:00
recurseIntoAttrs (linuxPackagesFor linux_2_6_32_systemtap pkgs.linuxPackages_2_6_32_systemtap);
linuxPackages_2_6_33 = recurseIntoAttrs (linuxPackagesFor linux_2_6_33 pkgs.linuxPackages_2_6_33);
linuxPackages_2_6_34 = recurseIntoAttrs (linuxPackagesFor linux_2_6_34 pkgs.linuxPackages_2_6_34);
kernel updates and add kernel 2.6.35.1 svn path=/nixpkgs/trunk/; revision=23155
2010-08-12 17:33:19 +01:00
linuxPackages_2_6_35 = recurseIntoAttrs (linuxPackagesFor linux_2_6_35 pkgs.linuxPackages_2_6_35);
Rename `kernel*' to `linux*'. svn path=/nixpkgs/branches/stdenv-updates/; revision=19068
2009-12-21 14:12:00 +00:00
* Put all packages that depend on a specific kernel (notably kernel modules) together in an attribute set returned by the function "kernelPackagesFor" that takes a kernel as argument. For instance, kernelPackages_2_6_23 is the result of calling this function with kernel_2_6_23. This is necessary in NixOS to make it easier to override the kernel: it's not enough to just specify a different kernel (via the boot.kernel option), but you also need matching nvidiaDriver, aufs, iwlwifi, etc. Having a single attribute set that contains all kernel-related packages makes this much easier. * The kernel now has a passthru attribute "features" that allows NixOS expressions to test whether a kernel has certain features. For instance, the externel "iwlwifi" kernel module package should only be built on kernels < 2.6.24, as kernels >= 2.6.24 have iwlwifi support integrated. So the NixOS expressions can do the test "kernel.features ? iwlwifi" to see if the iwlwifi package should be built. Kernel patches can declare additional features. E.g., the fbsplash patch adds a "fbSplash" feature. svn path=/nixpkgs/trunk/; revision=11881
2008-05-22 13:01:24 +01:00
# The current default kernel / kernel modules.
Merging from trunk. I fixed conflicts regarding the renaming 'kernel' -> 'linux' in all-packages. Also a small conflict in all-packages about making openssl overridable. And I some linux 2.6.31-zen kernel files also marked in conflict. svn path=/nixpkgs/branches/stdenv-updates/; revision=19438
2010-01-14 14:49:31 +00:00
linux = linux_2_6_32;
* Add callPackage etc. svn path=/nixpkgs/trunk/; revision=22876
2010-08-02 14:57:57 +01:00
linuxPackages = linuxPackages_2_6_32;
* Put all packages that depend on a specific kernel (notably kernel modules) together in an attribute set returned by the function "kernelPackagesFor" that takes a kernel as argument. For instance, kernelPackages_2_6_23 is the result of calling this function with kernel_2_6_23. This is necessary in NixOS to make it easier to override the kernel: it's not enough to just specify a different kernel (via the boot.kernel option), but you also need matching nvidiaDriver, aufs, iwlwifi, etc. Having a single attribute set that contains all kernel-related packages makes this much easier. * The kernel now has a passthru attribute "features" that allows NixOS expressions to test whether a kernel has certain features. For instance, the externel "iwlwifi" kernel module package should only be built on kernels < 2.6.24, as kernels >= 2.6.24 have iwlwifi support integrated. So the NixOS expressions can do the test "kernel.features ? iwlwifi" to see if the iwlwifi package should be built. Kernel patches can declare additional features. E.g., the fbsplash patch adds a "fbSplash" feature. svn path=/nixpkgs/trunk/; revision=11881
2008-05-22 13:01:24 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
keyutils = callPackage ../os-specific/linux/keyutils { };
Adding ecryptfs, and one of its dependencies: keyutils. (I have not tried whether they work) svn path=/nixpkgs/trunk/; revision=19645
2010-01-25 10:34:47 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libselinux = callPackage ../os-specific/linux/libselinux { };
libraw1394 added svn path=/nixpkgs/trunk/; revision=10121
2008-01-12 01:26:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libraw1394 = callPackage ../development/libraries/libraw1394 { };
libraw1394 added svn path=/nixpkgs/trunk/; revision=10121
2008-01-12 01:26:04 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
libsexy = callPackage ../development/libraries/libsexy {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gtkLibs) glib gtk pango;
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Gnome 2.22.1. * Moved some of the Gnome package Nix expressions into pkgs/desktops/gnome/default.nix - no need to have them in separate files. This way the code is much shorter. Still to be done for all the other Gnome packages. * Glib 2.16.3. svn path=/nixpkgs/branches/stdenv-updates/; revision=11855
2008-05-20 15:25:09 +01:00
librsvg = gnome.librsvg;
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libsepol = callPackage ../os-specific/linux/libsepol { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libsmbios = callPackage ../os-specific/linux/libsmbios { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lm_sensors = callPackage ../os-specific/linux/lm_sensors { };
* Doh. Forgot to commit. svn path=/nixpkgs/trunk/; revision=12863
2008-09-14 20:05:59 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lsiutil = callPackage ../os-specific/linux/lsiutil { };
* Added lsiutil, a command-line utility for LSI controllers. svn path=/nixpkgs/trunk/; revision=22437
2010-07-01 14:18:09 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
klibc = callPackage ../os-specific/linux/klibc {
Replace `kernelHeaders' by `linuxHeaders'. svn path=/nixpkgs/branches/stdenv-updates/; revision=19067
2009-12-21 14:04:45 +00:00
linuxHeaders = glibc.kernelHeaders;
* klibc: install statically linked binaries as well. * klibc: build against the regular kernel headers instead of depending on a kernel build. This way we don't have to rebuild klibc every time the kernel changes. * splashutils 1.3: compile properly with a klibc that uses unpatched kernel headers. svn path=/nixpkgs/trunk/; revision=13900
2009-01-29 15:44:37 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
klibcShrunk = callPackage ../os-specific/linux/klibc/shrunk.nix { };
* klibc: install statically linked binaries as well. * klibc: build against the regular kernel headers instead of depending on a kernel build. This way we don't have to rebuild klibc every time the kernel changes. * splashutils 1.3: compile properly with a klibc that uses unpatched kernel headers. svn path=/nixpkgs/trunk/; revision=13900
2009-01-29 15:44:37 +00:00
* Remove KVM (obsolete -> qemu-kvm). svn path=/nixpkgs/trunk/; revision=22796
2010-07-28 16:39:39 +01:00
kvm = qemu_kvm;
Updating xchm. svn path=/nixpkgs/trunk/; revision=18310
2009-11-09 11:55:31 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libcap = callPackage ../os-specific/linux/libcap { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libnscd = callPackage ../os-specific/linux/libnscd { };
* Added Valknut. svn path=/nixpkgs/trunk/; revision=3746
2005-08-30 08:39:38 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
libnotify = callPackage ../development/libraries/libnotify {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gtkLibs) gtk glib;
};
Added Falling Sand Game and wxGTK without unicode for it. svn path=/nixpkgs/trunk/; revision=9543
2007-10-27 18:55:13 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
libvolume_id = callPackage ../os-specific/linux/libvolume_id { };
* Added wxGTK/wxPython 2.8. However this was quite pointless as Bittorrent is even more broken with wxPython 2.8. svn path=/nixpkgs/trunk/; revision=8812
2007-05-31 14:43:13 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lvm2 = callPackage ../os-specific/linux/lvm2 { };
Added Falling Sand Game and wxGTK without unicode for it. svn path=/nixpkgs/trunk/; revision=9543
2007-10-27 18:55:13 +01:00
GNU Mach: Add full build. svn path=/nixpkgs/trunk/; revision=21986
2010-05-26 09:55:55 +01:00
# In theory GNU Mach doesn't have to be cross-compiled. However, since it
# has to be built for i586 (it doesn't work on x86_64), one needs a cross
# compiler for that host.
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
mach = callPackage ../os-specific/gnu/mach {
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
automake = automake111x; };
GNU Mach: Add full build. svn path=/nixpkgs/trunk/; revision=21986
2010-05-26 09:55:55 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
machHeaders = callPackage ../os-specific/gnu/mach {
Add GNU Mach (headers). svn path=/nixpkgs/trunk/; revision=21749
2010-05-12 16:46:38 +01:00
automake = automake111x;
headersOnly = true;
* More cleanup. svn path=/nixpkgs/trunk/; revision=22798
2010-07-28 19:01:17 +01:00
mig = null;
Add GNU Mach (headers). svn path=/nixpkgs/trunk/; revision=21749
2010-05-12 16:46:38 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mdadm = callPackage ../os-specific/linux/mdadm { };
* Updated Sylpheed to 2.1.9 and added GPG support (through gpgme). svn path=/nixpkgs/trunk/; revision=4400
2005-12-19 10:34:01 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mingetty = callPackage ../os-specific/linux/mingetty { };
* Added the OpenAL sound library. * Enabled (optional) 3D support in SDL. svn path=/nixpkgs/trunk/; revision=4594
2006-01-26 14:01:08 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
module_init_tools = callPackage ../os-specific/linux/module-init-tools { };
* Added APR. svn path=/nixpkgs/trunk/; revision=6484
2006-09-11 09:45:01 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
mountall = callPackage ../os-specific/linux/mountall {
* Added mountall. This is an Ubuntu utility that mounts filesystems as they become available (as determined by monitoring udev) and emits Upstart events to inform other jobs that the filesystems are mounted. This is very useful for NixOS (which currently ignores filesystems in the job dependency chain - very bad). Unfortunately, mountall depends on Plymouth (a boot splash implementation). The patch allows mountall to build without Plymouth. Since Plymouth is also used to inform users about failing mounts and get responses, some more changes will be needed. Probably mountall should emit a "mount-failed" event to trigger a root shell on the console to allow the user to repair the problem. svn path=/nixpkgs/trunk/; revision=22143
2010-06-04 14:43:53 +01:00
automake = automake111x;
};
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
aggregateModules = modules:
* Clean up indentation (expanded tabs etc.). svn path=/nixpkgs/trunk/; revision=11150
2008-03-17 09:41:28 +00:00
import ../os-specific/linux/module-init-tools/aggregator.nix {
* Module aggregator: use buildEnv, which is much faster because it creates symlinks lazily (i.e., it creates a single symlink to an entire tree unless another input has an overlapping tree). As a result it creates only a few dozen symlinks instead of ~ 12000 (which can take almost 2 minutes on my laptop). svn path=/nixpkgs/branches/stdenv-updates/; revision=15200
2009-04-20 20:13:40 +01:00
inherit stdenv module_init_tools modules buildEnv;
* Clean up indentation (expanded tabs etc.). svn path=/nixpkgs/trunk/; revision=11150
2008-03-17 09:41:28 +00:00
};
Added module_aggregator. Pass some directories with modules to it, and it will give you a directory to use instead of pkgs.kernel . addSbinPath in builderDefs to use sbin/ in addToEnv . Some catching up in xlaunch. svn path=/nixpkgs/trunk/; revision=10075
2008-01-04 17:02:12 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
modutils = callPackage ../os-specific/linux/modutils {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
stdenv = overrideGCC stdenv gcc34;
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
nettools = callPackage ../os-specific/linux/net-tools { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
neverball = callPackage ../games/neverball { };
Adding neverball 1.5.0, which comes with neverputt. Fun. svn path=/nixpkgs/trunk/; revision=14338
2009-03-04 17:28:25 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
numactl = callPackage ../os-specific/linux/numactl { };
Add numactl/libnuma, Linux-specific NUMA support tools. svn path=/nixpkgs/trunk/; revision=11656
2008-04-18 15:38:27 +01:00
Gateway6 client update svn path=/nixpkgs/trunk/; revision=14746
2009-03-28 15:22:52 +00:00
gw6c = builderDefsPackage (import ../os-specific/linux/gw6c) {
Updated gw6c and cleaned up the expression svn path=/nixpkgs/trunk/; revision=11614
2008-04-13 09:23:58 +01:00
inherit fetchurl stdenv nettools openssl procps iproute;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
nss_ldap = callPackage ../os-specific/linux/nss_ldap { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pam = callPackage ../os-specific/linux/pam { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Add entries for pmount & pam_usb in all-packages.nix. svn path=/nixpkgs/trunk/; revision=19184
2010-01-03 11:13:05 +00:00
# pam_bioapi ( see http://www.thinkwiki.org/wiki/How_to_enable_the_fingerprint_reader )
pam_ccreds: to locally authenticate using an enterprise identity when the network is unavailable. svn path=/nixpkgs/trunk/; revision=22987
2010-08-06 09:50:58 +01:00
pam_ccreds = callPackage ../os-specific/linux/pam_ccreds {
db = db4;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
pam_console = callPackage ../os-specific/linux/pam_console {
* pam_console needs an old libtool. svn path=/nixpkgs/branches/stdenv-updates/; revision=14791
2009-03-30 16:31:47 +01:00
libtool = libtool_1_5;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
flex = if stdenv.system == "i686-linux" then flex else flex2533;
};
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pam_devperm = callPackage ../os-specific/linux/pam_devperm { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
pam_krb5: added version 2.3.11-1. svn path=/nixpkgs/trunk/; revision=22984
2010-08-06 09:49:05 +01: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 17:26:58 +01:00
pam_ldap = callPackage ../os-specific/linux/pam_ldap { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pam_login = callPackage ../os-specific/linux/pam_login { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pam_unix2 = callPackage ../os-specific/linux/pam_unix2 { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pam_usb = callPackage ../os-specific/linux/pam_usb { };
* Add entries for pmount & pam_usb in all-packages.nix. svn path=/nixpkgs/trunk/; revision=19184
2010-01-03 11:13:05 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
pcmciaUtils = callPackage ../os-specific/linux/pcmciautils {
Add pcmcia-utils. Merge branch 'tmp' into tmp2 svn path=/nixpkgs/trunk/; revision=12432
2008-07-25 16:54:19 +01:00
pcmcia-utils: - Fix udev rules. - Accept multiple firmwares. - Allow redefinition of arguments. svn path=/nixpkgs/trunk/; revision=12741
2008-08-27 14:59:33 +01:00
firmware = getConfig ["pcmciaUtils" "firmware"] [];
Add pcmcia-utils. Merge branch 'tmp' into tmp2 svn path=/nixpkgs/trunk/; revision=12432
2008-07-25 16:54:19 +01:00
config = getConfig ["pcmciaUtils" "config"] null;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pmount = callPackage ../os-specific/linux/pmount { };
* Add entries for pmount & pam_usb in all-packages.nix. svn path=/nixpkgs/trunk/; revision=19184
2010-01-03 11:13:05 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pmutils = callPackage ../os-specific/linux/pm-utils { };
* Added pm-utils. svn path=/nixpkgs/trunk/; revision=17430
2009-09-25 22:43:25 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
powertop = callPackage ../os-specific/linux/powertop { };
moved vim_configurable to much more sensible place svn path=/nixpkgs/trunk/; revision=9931
2007-12-13 22:15:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
procps = callPackage ../os-specific/linux/procps { };
* Added apr-util. svn path=/nixpkgs/trunk/; revision=6485
2006-09-11 10:17:28 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pwdutils = callPackage ../os-specific/linux/pwdutils { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
qemu_kvm = callPackage ../os-specific/linux/qemu-kvm { };
* qemu-kvm is the upstream renaming of the kvm package. It no longer contains the kernel module, which we didn't build anyway. The kvm package can be deleted eventually. svn path=/nixpkgs/trunk/; revision=16582
2009-08-04 17:02:27 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
radeontools = callPackage ../os-specific/linux/radeontools { };
Moved a number of Java libraries from the GW project to the Nix Package Collection. svn path=/nixpkgs/trunk/; revision=3803
2005-09-11 16:38:59 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
rfkill = callPackage ../os-specific/linux/rfkill { };
* Added rfkill, a tool for controlling the wireless kill switch on Linux. svn path=/nixpkgs/trunk/; revision=21199
2010-04-21 12:21:15 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
rt2870fw = callPackage ../os-specific/linux/firmware/rt2870 { };
Adding firmware for the wireless cards rt2870 (for a rt3072 hw in fact) svn path=/nixpkgs/trunk/; revision=22551
2010-07-09 18:30:08 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
rt73fw = callPackage ../os-specific/linux/firmware/rt73 { };
Adding the firmware for the rt73 usb wifi nic. svn path=/nixpkgs/trunk/; revision=17263
2009-09-18 21:45:10 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
sdparm = callPackage ../os-specific/linux/sdparm { };
Moved a number of Java libraries from the GW project to the Nix Package Collection. svn path=/nixpkgs/trunk/; revision=3803
2005-09-11 16:38:59 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
shadow = callPackage ../os-specific/linux/shadow { };
Moved a number of Java libraries from the GW project to the Nix Package Collection. svn path=/nixpkgs/trunk/; revision=3803
2005-09-11 16:38:59 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
splashutils = callPackage ../os-specific/linux/splashutils/default.nix { };
* splashutils_13 / splashutils_15: these don't depend on the kernel version. * Add klibc and splashutils to the channel. svn path=/nixpkgs/trunk/; revision=13901
2009-01-29 15:56:01 +00:00
Adding statifier, a tool to make pseudostatic binaries. Unfortunately, statified NixOS-built binaries segfault on Ubuntu.. svn path=/nixpkgs/trunk/; revision=16291
2009-07-09 22:34:29 +01:00
statifier = builderDefsPackage (import ../os-specific/linux/statifier) {
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
sysfsutils = callPackage ../os-specific/linux/sysfsutils { };
Add sysfsutils. svn path=/nixpkgs/trunk/; revision=12431
2008-07-25 16:53:23 +01: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 17:26:58 +01:00
sysklogd = callPackage ../os-specific/linux/sysklogd { };
Moved a number of Java libraries from the GW project to the Nix Package Collection. svn path=/nixpkgs/trunk/; revision=3803
2005-09-11 16:38:59 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
syslinux = callPackage ../os-specific/linux/syslinux { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
sysstat = callPackage ../os-specific/linux/sysstat { };
add RPM. But: - untested - no Python bindings - experimental version (this is not the "stable" production branch) svn path=/nixpkgs/trunk/; revision=4403
2005-12-20 00:48:38 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
sysvinit = callPackage ../os-specific/linux/sysvinit { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
sysvtools = callPackage ../os-specific/linux/sysvinit {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
withoutInitTools = true;
};
Add `tcp-wrapper'. svn path=/nixpkgs/trunk/; revision=11136
2008-03-15 22:41:31 +00: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 17:26:58 +01:00
tcpWrapper = callPackage ../os-specific/linux/tcp-wrapper { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
trackballs = callPackage ../games/trackballs {
Adding trackballs svn path=/nixpkgs/trunk/; revision=15625
2009-05-17 00:14:37 +01:00
debug = 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 17:26:58 +01:00
tunctl = callPackage ../os-specific/linux/tunctl { };
Adding tunctl. I didn't know how to build the manpage, though. svn path=/nixpkgs/trunk/; revision=14290
2009-03-01 21:34:39 +00:00
All-packages.nix updates.. svn path=/nixpkgs/trunk/; revision=14153
2009-02-21 18:59:15 +00: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 17:35:47 +00:00
ubootChooser = name : if (name == "upstream") then ubootUpstream
else if (name == "sheevaplug") then ubootSheevaplug
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 17:26:58 +01:00
ubootUpstream = callPackage ../misc/uboot { };
Porting changes from stdenv-updates into this branch. This comes from: svn diff ^/nixpkgs/trunk/@18255 ^/nixpkgs/branches/stdenv-updates/ > diff patch -p0 < diff and then adding into svn all files new from the patch. trunk@18255 comes from the last time I updated stdenv-updates from trunk. svn path=/nixpkgs/stdenv-updates2/; revision=18272
2009-11-08 00:32:12 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ubootSheevaplug = callPackage ../misc/uboot/sheevaplug.nix { };
Adding the mainline uboot. svn path=/nixpkgs/trunk/; revision=20078
2010-02-17 20:53:01 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
uclibc = callPackage ../os-specific/linux/uclibc { };
Porting changes from stdenv-updates into this branch. This comes from: svn diff ^/nixpkgs/trunk/@18255 ^/nixpkgs/branches/stdenv-updates/ > diff patch -p0 < diff and then adding into svn all files new from the patch. trunk@18255 comes from the last time I updated stdenv-updates from trunk. svn path=/nixpkgs/stdenv-updates2/; revision=18272
2009-11-08 00:32:12 +00:00
Enabling cross-builds with uclibc again (I had that too much abandoned). Hydra now should even test it. svn path=/nixpkgs/trunk/; revision=20500
2010-03-09 15:48:25 +00:00
uclibcCross = import ../os-specific/linux/uclibc {
Making the cross-builds work with uclibc. There is no easy way of switching between uclibc/glibc still. I started the renaming from glibc to libc regarding the cross-toolchain, but I still have to finish. svn path=/nixpkgs/branches/stdenv-updates/; revision=18801
2009-12-04 13:35:58 +00:00
inherit fetchurl stdenv;
Enabling cross-builds with uclibc again (I had that too much abandoned). Hydra now should even test it. svn path=/nixpkgs/trunk/; revision=20500
2010-03-09 15:48:25 +00:00
linuxHeaders = linuxHeadersCross;
gccCross = gccCrossStageStatic;
cross = assert crossSystem != null; crossSystem;
Making the cross-builds work with uclibc. There is no easy way of switching between uclibc/glibc still. I started the renaming from glibc to libc regarding the cross-toolchain, but I still have to finish. svn path=/nixpkgs/branches/stdenv-updates/; revision=18801
2009-12-04 13:35:58 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
udev = callPackage ../os-specific/linux/udev { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Added a script to generate the kernel configuration. `generate-config.pl' runs `make config' to generate a Linux kernel configuration file. For each question (i.e. kernel configuration option), unless an override is provided, it answers "m" if possible, and otherwise uses the default answer (as determined by the default config for the architecture). This is safer than allmodconfig, which answers "y" everywhere it can't answer "m" and thus ends up enabling a lot of experimental or debug options. (For this reason, a configuration generated by allmodconfig must be carefully checked with every new release to ensure that nothing dangerous is enabled. The default config should be safer wrt new kernel releases.) Overrides are specified in the `config' argument to generic.nix, which is a string that contains lines such as `EXT2_FS_POSIX_ACL y'. The script warns about ignored options, and aborts if `make config' selects an answer inconsistent with the one in `config'. This allows us to be sure that `make config' doesn't silently override our configuration values (e.g., depending on other options, it will set FB_TILEBLITTING to "y" even if we want it to be "n"). svn path=/nixpkgs/branches/kernel-config/; revision=18910
2009-12-12 13:51:07 +00:00
uml = import ../os-specific/linux/kernel/linux-2.6.29.nix {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit fetchurl stdenv perl mktemp module_init_tools;
userModeLinux = true;
};
d4x (gui downloader for X) added svn path=/nixpkgs/trunk/; revision=9304
2007-09-11 20:27:25 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
umlutilities = callPackage ../os-specific/linux/uml-utilities {
added support for building uml_mconsole svn path=/nixpkgs/trunk/; revision=12433
2008-07-26 02:02:27 +01:00
tunctl = true; mconsole = true;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
* Added darcs 1.0.3. svn path=/nixpkgs/trunk/; revision=4009
2005-10-04 15:25:13 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
upstart = callPackage ../os-specific/linux/upstart { };
* Upstart 0.6.2. svn path=/nixpkgs/trunk/; revision=18056
2009-10-30 18:12:28 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
usbutils = callPackage ../os-specific/linux/usbutils { };
Added djview4 svn path=/nixpkgs/trunk/; revision=9642
2007-11-11 16:52:29 +00:00
* Got rid of the old util-linux; use util-linux-ng instead. svn path=/nixpkgs/trunk/; revision=14799
2009-03-31 10:26:47 +01:00
utillinux = utillinuxng;
Added DVD+RW tools svn path=/nixpkgs/trunk/; revision=9911
2007-12-11 22:58:44 +00:00
* Got rid of the old util-linux; use util-linux-ng instead. svn path=/nixpkgs/trunk/; revision=14799
2009-03-31 10:26:47 +01:00
utillinuxCurses = utillinuxngCurses;
* Updated Eclipse to 3.2.2 * Added Eclipse to the nixpkgs channel (which is possible now we can deploy the jdk) svn path=/nixpkgs/trunk/; revision=8317
2007-03-17 13:29:15 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
utillinuxng = callPackage ../os-specific/linux/util-linux-ng {
* Turn vim/default.nix into a regular package. We don't need two configurable VIMs. svn path=/nixpkgs/trunk/; revision=22784
2010-07-28 13:52:54 +01:00
ncurses = null;
* Added util-linux-ng, a fork of util-linux (which seems unmaintained). svn path=/nixpkgs/trunk/; revision=13712
2009-01-06 09:28:45 +00:00
};
* Got rid of the old util-linux; use util-linux-ng instead. svn path=/nixpkgs/trunk/; revision=14799
2009-03-31 10:26:47 +01:00
utillinuxngCurses = utillinuxng.override {
inherit ncurses;
Build e2fsprogs at last svn path=/nixpkgs/trunk/; revision=13719
2009-01-06 23:22:29 +00:00
};
Making wxGTK stay wxGTK even cross-built, so I remove the wxMSW code I added to test the crossbuilding with wxGTK. I added a new windows-specific package: wxMSW. svn path=/nixpkgs/trunk/; revision=21634
2010-05-06 20:19:22 +01:00
windows = rec {
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
w32api = callPackage ../os-specific/windows/w32api {
Making wxGTK stay wxGTK even cross-built, so I remove the wxMSW code I added to test the crossbuilding with wxGTK. I added a new windows-specific package: wxMSW. svn path=/nixpkgs/trunk/; revision=21634
2010-05-06 20:19:22 +01:00
gccCross = gccCrossStageStatic;
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
binutilsCross = binutilsCross; };
Making gcc-4.5 cross-build to mingw32 too (set by the proper config and libc = "msvcrt" in the crossSystem) svn path=/nixpkgs/trunk/; revision=21630
2010-05-06 19:22:51 +01:00
Making wxGTK stay wxGTK even cross-built, so I remove the wxMSW code I added to test the crossbuilding with wxGTK. I added a new windows-specific package: wxMSW. svn path=/nixpkgs/trunk/; revision=21634
2010-05-06 20:19:22 +01:00
w32api_headers = w32api.override {
onlyHeaders = true;
};
Making gcc-4.5 cross-build to mingw32 too (set by the proper config and libc = "msvcrt" in the crossSystem) svn path=/nixpkgs/trunk/; revision=21630
2010-05-06 19:22:51 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
mingw_runtime = callPackage ../os-specific/windows/mingwrt {
Making wxGTK stay wxGTK even cross-built, so I remove the wxMSW code I added to test the crossbuilding with wxGTK. I added a new windows-specific package: wxMSW. svn path=/nixpkgs/trunk/; revision=21634
2010-05-06 20:19:22 +01:00
gccCross = gccCrossMingw2;
binutilsCross = binutilsCross;
};
Making gcc-4.5 cross-build to mingw32 too (set by the proper config and libc = "msvcrt" in the crossSystem) svn path=/nixpkgs/trunk/; revision=21630
2010-05-06 19:22:51 +01:00
Making wxGTK stay wxGTK even cross-built, so I remove the wxMSW code I added to test the crossbuilding with wxGTK. I added a new windows-specific package: wxMSW. svn path=/nixpkgs/trunk/; revision=21634
2010-05-06 20:19:22 +01:00
mingw_runtime_headers = mingw_runtime.override {
onlyHeaders = true;
};
Making gcc-4.5 cross-build to mingw32 too (set by the proper config and libc = "msvcrt" in the crossSystem) svn path=/nixpkgs/trunk/; revision=21630
2010-05-06 19:22:51 +01:00
Making wxGTK stay wxGTK even cross-built, so I remove the wxMSW code I added to test the crossbuilding with wxGTK. I added a new windows-specific package: wxMSW. svn path=/nixpkgs/trunk/; revision=21634
2010-05-06 20:19:22 +01:00
mingw_headers1 = buildEnv {
name = "mingw-headers-1";
paths = [ w32api_headers mingw_runtime_headers ];
};
Making gcc-4.5 cross-build to mingw32 too (set by the proper config and libc = "msvcrt" in the crossSystem) svn path=/nixpkgs/trunk/; revision=21630
2010-05-06 19:22:51 +01:00
Making wxGTK stay wxGTK even cross-built, so I remove the wxMSW code I added to test the crossbuilding with wxGTK. I added a new windows-specific package: wxMSW. svn path=/nixpkgs/trunk/; revision=21634
2010-05-06 20:19:22 +01:00
mingw_headers2 = buildEnv {
name = "mingw-headers-2";
paths = [ w32api mingw_runtime_headers ];
};
mingw_headers3 = buildEnv {
name = "mingw-headers-3";
paths = [ w32api mingw_runtime ];
};
Making gcc-4.5 cross-build to mingw32 too (set by the proper config and libc = "msvcrt" in the crossSystem) svn path=/nixpkgs/trunk/; revision=21630
2010-05-06 19:22:51 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
wxMSW = callPackage ../os-specific/windows/wxMSW-2.8 { };
Making gcc-4.5 cross-build to mingw32 too (set by the proper config and libc = "msvcrt" in the crossSystem) svn path=/nixpkgs/trunk/; revision=21630
2010-05-06 19:22:51 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
wesnoth = callPackage ../games/wesnoth {
update to 1.6.5 svn path=/nixpkgs/trunk/; revision=19128
2009-12-25 20:56:37 +00:00
inherit (gtkLibs) pango;
forgot to update all-packages.nix svn path=/nixpkgs/trunk/; revision=10530
2008-02-06 21:26:17 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
wirelesstools = callPackage ../os-specific/linux/wireless-tools { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
wpa_supplicant = callPackage ../os-specific/linux/wpa_supplicant {
wpa_supplicant: enable qt gui, deprecate old broken derivation building gui svn path=/nixpkgs/trunk/; revision=21332
2010-04-27 05:38:41 +01:00
guiSupport = false;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
wpa_supplicant: enable qt gui, deprecate old broken derivation building gui svn path=/nixpkgs/trunk/; revision=21332
2010-04-27 05:38:41 +01:00
# prebuild binaries:
wpa_supplicant_gui = wpa_supplicant.override { guiSupport = true; };
* ion-3 and elinks added, missprint in qt-4 corrected svn path=/nixpkgs/trunk/; revision=8993
2007-07-17 20:29:53 +01:00
wpa_supplicant: enable qt gui, deprecate old broken derivation building gui svn path=/nixpkgs/trunk/; revision=21332
2010-04-27 05:38:41 +01:00
# deprecated, but contains icon ? Does no longer build
/* didn't build Sun Apr 25 20:34:18 CEST 2010
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
wpa_supplicant_gui_qt4_old = callPackage ../os-specific/linux/wpa_supplicant/gui-qt4.nix { };
wpa_supplicant: enable qt gui, deprecate old broken derivation building gui svn path=/nixpkgs/trunk/; revision=21332
2010-04-27 05:38:41 +01:00
*/
Added qt4 gui front-end package for WPA supplicant svn path=/nixpkgs/trunk/; revision=15578
2009-05-12 19:52:48 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xf86_input_wacom = callPackage ../os-specific/linux/xf86-input-wacom { };
Initial xf86-input-wacom nix expression Builds here. Haven't tested whether it works with real hardware yet. svn path=/nixpkgs/trunk/; revision=21019
2010-04-11 23:42:28 +01:00
Added Open Dynamics Engine svn path=/nixpkgs/trunk/; revision=13520
2008-11-30 16:50:05 +00: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
lua5 ode;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xorg_sys_opengl = callPackage ../os-specific/linux/opengl/xorg-sys { };
* Emacs 22.1. This is the default now, but 21.4 is still around (as is the 23.0.0.1 alpha). svn path=/nixpkgs/trunk/; revision=9175
2007-08-20 14:48:56 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
zd1211fw = callPackage ../os-specific/linux/firmware/zd1211 { };
* Added Sylpheed 1.9.11 (beta for GTK 2). svn path=/nixpkgs/trunk/; revision=3149
2005-05-26 21:09:29 +01:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
### DATA
* Added Valknut. svn path=/nixpkgs/trunk/; revision=3746
2005-08-30 08:39:38 +01:00
Added ArkPandora fonts svn path=/nixpkgs/trunk/; revision=12264
2008-07-05 06:26:58 +01:00
arkpandora_ttf = builderDefsPackage (import ../data/fonts/arkpandora) {
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
bakoma_ttf = callPackage ../data/fonts/bakoma-ttf { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cacert = callPackage ../data/misc/cacert { };
* Added a bundle of CA certificates, useful for e.g. curl. svn path=/nixpkgs/trunk/; revision=19571
2010-01-20 14:10:26 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
corefonts = callPackage ../data/fonts/corefonts { };
exrviewer added (needs ctl openexr openexr_ctl) fltk update ilmbase updated ndiswrapper does compile but has to be integrated into the kernel somehow svn path=/nixpkgs/trunk/; revision=9863
2007-12-05 21:25:47 +00:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
wrapFonts = paths : ((import ../data/fonts/fontWrap) {
Added UCS-fonts svn path=/nixpkgs/trunk/; revision=10915
2008-03-02 19:19:34 +00:00
inherit fetchurl stdenv builderDefs paths ttmkfdir;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (xorg) mkfontdir mkfontscale;
});
Added fbpanel - desktop panel. svn path=/nixpkgs/trunk/; revision=9774
2007-11-22 04:23:27 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
clearlyU = callPackage ../data/fonts/clearlyU { };
Added template to use deb-package wrapper. svn path=/nixpkgs/trunk/; revision=10911
2008-03-02 18:41:32 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
dejavu_fonts = callPackage ../data/fonts/dejavu-fonts {
* Drop the "perl" prefix from Perl attribute names. It's redundant now that Perl packages are in their own namespace (perlPackages.<pkg>). svn path=/nixpkgs/trunk/; revision=15176
2009-04-20 13:49:35 +01:00
inherit (perlPackages) FontTTF;
Added template to use deb-package wrapper. svn path=/nixpkgs/trunk/; revision=10911
2008-03-02 18:41:32 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
docbook5 = callPackage ../data/sgml+xml/schemas/docbook-5.0 { };
Added fbpanel - desktop panel. svn path=/nixpkgs/trunk/; revision=9774
2007-11-22 04:23:27 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
docbook_xml_dtd_412 = callPackage ../data/sgml+xml/schemas/xml-dtd/docbook/4.1.2.nix { };
added: dnsmasq, uisp, fltk libixp_for_wmii, acerhk kernel module, reiserfsprogs, radeontools, msmtp, procmail, pstree, gxemul changed: umlutilities to also support building tunctl optionally (needing kernel header files) wmii updated and wmiimenu added svn path=/nixpkgs/trunk/; revision=9242
2007-09-03 13:10:57 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
docbook_xml_dtd_42 = callPackage ../data/sgml+xml/schemas/xml-dtd/docbook/4.2.nix { };
add the mozilla browser. The compilation process is nearly identical to firefox, but there are some differences: - don't source in $topsrcdir/browser/config/mozconfig (does not exist it seems) - different source tarball (different version that is) - leave out the postinstall phase svn path=/nixpkgs/trunk/; revision=4116
2005-10-22 12:51:30 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
docbook_xml_dtd_43 = callPackage ../data/sgml+xml/schemas/xml-dtd/docbook/4.3.nix { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
docbook_xml_dtd_45 = callPackage ../data/sgml+xml/schemas/xml-dtd/docbook/4.5.nix { };
pkgs/data/sgml+xml/schemas/xml-dtd/docbook/4.5.nix: added docbook 4.5 XML DTD The new asciidoc version generates docbook output for this version. svn path=/nixpkgs/trunk/; revision=18077
2009-11-03 15:57:27 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
docbook_xml_ebnf_dtd = callPackage ../data/sgml+xml/schemas/xml-dtd/docbook-ebnf { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00: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 17:26:58 +01:00
docbook_xsl = callPackage ../data/sgml+xml/stylesheets/xslt/docbook-xsl { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* docbook-xsl / docbook-xsl-ns: match the upstream package name. Also updated docbook-xsl-ns. svn path=/nixpkgs/trunk/; revision=16356
2009-07-14 16:02:56 +01: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 17:26:58 +01:00
docbook_xsl_ns = callPackage ../data/sgml+xml/stylesheets/xslt/docbook-xsl-ns { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
freefont_ttf = callPackage ../data/fonts/freefont-ttf { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Added pkgs/data/misc/hicolor-icon-theme, required by Xfce. svn path=/nixpkgs/trunk/; revision=23060
2010-08-09 19:00:08 +01:00
hicolor_icon_theme = callPackage ../data/misc/hicolor-icon-theme { };
pkgs/top-level/all-packages.nix: strip trailing whitenspace svn path=/nixpkgs/trunk/; revision=23118
2010-08-11 16:49:42 +01:00
* Added pkgs/data/misc/hicolor-icon-theme, required by Xfce. svn path=/nixpkgs/trunk/; revision=23060
2010-08-09 19:00:08 +01: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 17:26:58 +01:00
liberation_ttf = callPackage ../data/fonts/redhat-liberation-fonts { };
Added template to use deb-package wrapper. svn path=/nixpkgs/trunk/; revision=10911
2008-03-02 18:41:32 +00:00
* Removed selectVersion. There's no good reason to write `selectVersion ./foo "bar"' instead of `import ./foo/bar.nix'. * Replaced `with args' with formal function arguments in several packages. * Renamed several files to `default.nix'. As a general rule, version numbers should only be included in the filename when there is a reason to keep multiple versions of a package in Nixpkgs. Otherwise, it just makes it harder to update the package. svn path=/nixpkgs/trunk/; revision=18403
2009-11-18 09:39:59 +00:00
libertine = builderDefsPackage (import ../data/fonts/libertine/2.7.nix) {
Added font building support to builder-defs; made realCurl configurable; added Linux Libertine font; added ConTEXt svn path=/nixpkgs/trunk/; revision=11739
2008-04-28 11:10:44 +01:00
inherit fontforge;
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
* Removed selectVersion. There's no good reason to write `selectVersion ./foo "bar"' instead of `import ./foo/bar.nix'. * Replaced `with args' with formal function arguments in several packages. * Renamed several files to `default.nix'. As a general rule, version numbers should only be included in the filename when there is a reason to keep multiple versions of a package in Nixpkgs. Otherwise, it just makes it harder to update the package. svn path=/nixpkgs/trunk/; revision=18403
2009-11-18 09:39:59 +00:00
libertineBin = builderDefsPackage (import ../data/fonts/libertine/2.7.bin.nix) {
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
Added font building support to builder-defs; made realCurl configurable; added Linux Libertine font; added ConTEXt svn path=/nixpkgs/trunk/; revision=11739
2008-04-28 11:10:44 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lmodern = callPackage ../data/fonts/lmodern { };
all-packages.nix changes for two previous commits svn path=/nixpkgs/trunk/; revision=11728
2008-04-26 16:23:46 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
manpages = callPackage ../data/documentation/man-pages { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
miscfiles = callPackage ../data/misc/miscfiles { };
Adding bsdgames and miscfiles (this later, for 'words') I could not easily make some bsdgames build or install. Too much patching against the installer trying to write beyond the nix store. svn path=/nixpkgs/trunk/; revision=17971
2009-10-26 23:03:36 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mph_2b_damase = callPackage ../data/fonts/mph-2b-damase { };
Added template to use deb-package wrapper. svn path=/nixpkgs/trunk/; revision=10911
2008-03-02 18:41:32 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pthreadmanpages = callPackage ../data/documentation/pthread-man-pages { };
Add pthread man pages from LinuxThreads. svn path=/nixpkgs/trunk/; revision=14837
2009-04-02 15:30:34 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
shared_mime_info = callPackage ../data/misc/shared-mime-info { };
pkgs/applications/editors/emacs-modes/magit: updated to version magit-0.7-94-gbf42bf8 Magit has seen plenty of development since version 0.7, but for some reason there haven't been any new releases. This version bump updates the expression to build a current version of Magit directly from the Git repository. This change adds buildInputs 'autoconf' and 'automake'. These tools are required only because we aren't building from a proper release tarball. Once version 0.8 comes out, these dependencies can be dropped again. svn path=/nixpkgs/trunk/; revision=20650
2010-03-16 12:13:40 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
shared_desktop_ontologies = callPackage ../data/misc/shared-desktop-ontologies { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
stdmanpages = callPackage ../data/documentation/std-man-pages { };
Adding C++ std man pages. svn path=/nixpkgs/trunk/; revision=14771
2009-03-30 09:14:19 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
iana_etc = callPackage ../data/misc/iana-etc { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
popplerData = callPackage ../data/misc/poppler-data { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
r3rs = callPackage ../data/documentation/rnrs/r3rs.nix { };
Add R[345]RS, revisions of the Report on the Algorithmic Language Scheme. svn path=/nixpkgs/trunk/; revision=11307
2008-03-27 14:40:08 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
r4rs = callPackage ../data/documentation/rnrs/r4rs.nix { };
Add R[345]RS, revisions of the Report on the Algorithmic Language Scheme. svn path=/nixpkgs/trunk/; revision=11307
2008-03-27 14:40:08 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
r5rs = callPackage ../data/documentation/rnrs/r5rs.nix { };
Add R[345]RS, revisions of the Report on the Algorithmic Language Scheme. svn path=/nixpkgs/trunk/; revision=11307
2008-03-27 14:40:08 +00:00
Copied Green theme declaration from NixOS source here svn path=/nixpkgs/trunk/; revision=13725
2009-01-08 22:21:32 +00:00
themes = name: import (../data/misc/themes + ("/" + name + ".nix")) {
inherit fetchurl;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
terminus_font = callPackage ../data/fonts/terminus-font { };
data/fonts/terminus-font: New nixpkg. svn path=/nixpkgs/trunk/; revision=19855
2010-02-06 22:28:39 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ttf_bitstream_vera = callPackage ../data/fonts/ttf-bitstream-vera { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ucsFonts = callPackage ../data/fonts/ucs-fonts { };
Added UCS-fonts svn path=/nixpkgs/trunk/; revision=10915
2008-03-02 19:19:34 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
unifont = callPackage ../data/fonts/unifont { };
Added template to use deb-package wrapper. svn path=/nixpkgs/trunk/; revision=10911
2008-03-02 18:41:32 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
vistafonts = callPackage ../data/fonts/vista-fonts { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
wqy_zenhei = callPackage ../data/fonts/wqy-zenhei { };
Added template to use deb-package wrapper. svn path=/nixpkgs/trunk/; revision=10911
2008-03-02 18:41:32 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xhtml1 = callPackage ../data/sgml+xml/schemas/xml-dtd/xhtml1 { };
* XHTML 1.0 DTDs. svn path=/nixpkgs/trunk/; revision=17185
2009-09-16 13:25:22 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xkeyboard_config = callPackage ../data/misc/xkeyboard-config { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
### APPLICATIONS
* Use callPackage_i686 for i686-only packages. svn path=/nixpkgs/trunk/; revision=23113
2010-08-11 14:25:30 +01:00
aangifte2005 = callPackage_i686 ../applications/taxes/aangifte-2005 { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage_i686 for i686-only packages. svn path=/nixpkgs/trunk/; revision=23113
2010-08-11 14:25:30 +01:00
aangifte2006 = callPackage_i686 ../applications/taxes/aangifte-2006 { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage_i686 for i686-only packages. svn path=/nixpkgs/trunk/; revision=23113
2010-08-11 14:25:30 +01:00
aangifte2007 = callPackage_i686 ../applications/taxes/aangifte-2007 { };
* Aangifte 2007. svn path=/nixpkgs/trunk/; revision=11134
2008-03-15 21:45:57 +00:00
* Use callPackage_i686 for i686-only packages. svn path=/nixpkgs/trunk/; revision=23113
2010-08-11 14:25:30 +01:00
aangifte2008 = callPackage_i686 ../applications/taxes/aangifte-2008 { };
* Added the Dutch Tax Return program for 2009. svn path=/nixpkgs/trunk/; revision=20828
2010-03-25 19:40:19 +00:00
* Use callPackage_i686 for i686-only packages. svn path=/nixpkgs/trunk/; revision=23113
2010-08-11 14:25:30 +01:00
aangifte2009 = callPackage_i686 ../applications/taxes/aangifte-2009 { };
* Aangifte 2007. svn path=/nixpkgs/trunk/; revision=11134
2008-03-15 21:45:57 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
abcde = callPackage ../applications/audio/abcde { };
Add abcde, a command-line CD encoder. svn path=/nixpkgs/trunk/; revision=11904
2008-05-26 21:54:34 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
abiword = callPackage ../applications/office/abiword {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gtkLibs) gtk;
update to 2.8.1 svn path=/nixpkgs/trunk/; revision=19113
2009-12-25 15:45:06 +00:00
inherit (gnome) libglade libgnomecanvas;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
* Use callPackage_i686 for i686-only packages. svn path=/nixpkgs/trunk/; revision=23113
2010-08-11 14:25:30 +01:00
adobeReader = callPackage_i686 ../applications/misc/adobe-reader {
* Adobe Reader: updated to 9.3.3. Make it installable on x86_64-linux. svn path=/nixpkgs/trunk/; revision=22956
2010-08-05 09:54:58 +01:00
inherit (pkgsi686Linux.gtkLibs) glib pango atk gtk;
* Adobe Reader 9.2. svn path=/nixpkgs/trunk/; revision=17799
2009-10-14 14:08:04 +01:00
};
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
amsn = callPackage ../applications/networking/instant-messengers/amsn {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
libstdcpp = gcc33.gcc;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
ardour = callPackage ../applications/audio/ardour {
adding ardour svn path=/nixpkgs/trunk/; revision=17327
2009-09-21 10:58:41 +01:00
inherit (gtkLibs) glib pango gtk glibmm gtkmm;
* aubio: lacked a version in the name attribute, and the description was broken. svn path=/nixpkgs/trunk/; revision=17807
2009-10-14 16:32:37 +01:00
inherit (gnome) libgnomecanvas;
adding ardour svn path=/nixpkgs/trunk/; revision=17327
2009-09-21 10:58:41 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
audacious = callPackage ../applications/audio/audacious {
* Added Audacious, a fork of beep-media-player (which doesn't seem to work very well after the Glibc update), plus its dependencies. TODO: make an audacious-wrapper that lets Audacious find its plugins automatically. Currently you have to install audacious-plugins and symlink ~/.nix-profile/lib/audacious/* in ~/.local/share/audacious/Plugins. svn path=/nixpkgs/trunk/; revision=10927
2008-03-03 10:55:20 +00:00
inherit (gtkLibs) glib gtk;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
audacity = callPackage ../applications/audio/audacity {
* Added AUFS, another Unionfs. svn path=/nixpkgs/trunk/; revision=10387
2008-01-29 13:24:40 +00:00
inherit (gtkLibs) gtk glib;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
aumix = callPackage ../applications/audio/aumix {
Add Aumix, an audio mixer. svn path=/nixpkgs/trunk/; revision=10627
2008-02-11 21:45:52 +00:00
inherit (gtkLibs) gtk;
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 17:26:58 +01:00
autopanosiftc = callPackage ../applications/graphics/autopanosiftc { };
Adding autopano-sift-C, a C implementation of autopano-sift, made by the hugin people. svn path=/nixpkgs/trunk/; revision=14916
2009-04-07 20:15:53 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
avidemux = callPackage ../applications/video/avidemux {
Adding avidemux. svn path=/nixpkgs/trunk/; revision=18584
2009-11-24 08:27:18 +00:00
inherit (gtkLibs) gtk;
Trying to fix the nixpkgs-tarball, after I broke it again due to assuming 'gcc' to be pure as that of stdenvLinux. svn path=/nixpkgs/trunk/; revision=20671
2010-03-16 21:53:48 +00:00
stdenv = stdenv2;
Adding avidemux. svn path=/nixpkgs/trunk/; revision=18584
2009-11-24 08:27:18 +00:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
awesome = callPackage ../applications/window-managers/awesome {
Adding 'awesome' (and two packages it was depending on) svn path=/nixpkgs/trunk/; revision=20385
2010-03-04 14:44:56 +00:00
inherit (gtkLibs) glib pango;
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 17:26:58 +01:00
cairo = cairo.override { xcbSupport = true;
};
Adding 'awesome' (and two packages it was depending on) svn path=/nixpkgs/trunk/; revision=20385
2010-03-04 14:44:56 +00:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
bangarang = callPackage ../applications/video/bangarang {
Added Bangarang media player svn path=/nixpkgs/trunk/; revision=22423
2010-06-26 19:29:42 +01:00
inherit (kde4) qt4 kdelibs automoc4 phonon soprano kdemultimedia;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
batik = callPackage ../applications/graphics/batik { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
bazaar = callPackage ../applications/version-management/bazaar {
Adding possibility to have rich Python installation for development but use only the base one for, say, OpenOffice (and be able to use buildfarm). Codeville and Bazaar use the rich variant - they do have some use for it.. svn path=/nixpkgs/trunk/; revision=13075
2008-10-15 21:01:39 +01:00
python = pythonFull;
* makeWrapper: new function that transparently takes care of creating a wrapper script. E.g. wrapProgram $out/bin/prog --set FOO bar will create a wrapper around "prog" so that the environment variable FOO is set to bar. The original program is renamed to $out/bin/.wrapped-prog. * Function makeSetupHook to convert a script into a setup hook which can be included in buildInputs. This makes it easier to use scripts like makeWrapper. * Added Bazaar, yet another distributed version management system. svn path=/nixpkgs/trunk/; revision=10211
2008-01-18 10:29:58 +00:00
};
Added bazaar tools (not installed globally, just copied to share, you have to symlink them to your ~/.bazaar/plugins). Also readline support for python. svn path=/nixpkgs/trunk/; revision=11893
2008-05-26 12:39:08 +01:00
bazaarTools = builderDefsPackage (import ../applications/version-management/bazaar/tools.nix) {
inherit bazaar;
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
Added bazaar tools (not installed globally, just copied to share, you have to symlink them to your ~/.bazaar/plugins). Also readline support for python. svn path=/nixpkgs/trunk/; revision=11893
2008-05-26 12:39:08 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
beast = callPackage ../applications/audio/beast {
* Fix some more "args: with args". svn path=/nixpkgs/trunk/; revision=22828
2010-07-30 15:47:23 +01:00
# stdenv = overrideGCC stdenv gcc34;
added beast Sound Engine svn path=/nixpkgs/trunk/; revision=12647
2008-08-18 11:50:16 +01:00
inherit (gtkLibs) gtk glib;
inherit (gnome) libgnomecanvas libart_lgpl;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
bitlbee = callPackage ../applications/networking/instant-messengers/bitlbee { };
Add BitlBee, an IRC to other chat networks gateway. svn path=/nixpkgs/trunk/; revision=10715
2008-02-17 15:33:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
bitlbeeOtr = callPackage ../applications/networking/instant-messengers/bitlbee-otr { };
Add Bitbee-OTR, an unofficial version of Bitlbee with OTR support. svn path=/nixpkgs/trunk/; revision=12925
2008-09-26 10:03:22 +01:00
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
# commented out because it's using the new configuration style proposal which is unstable
#biew = import ../applications/misc/biew {
# inherit lib stdenv fetchurl ncurses;
#};
# only to be able to compile blender - I couldn't compile the default openal software
# Perhaps this can be removed - don't know which one openal{,soft} is better
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
freealut_soft = callPackage ../development/libraries/freealut {
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
openal = openalSoft; };
* Merged most of the stdenv-updates branch. Some stuff didn't merge cleanly right away (kde-4, kernel stuff) so it should be merged later. But the stdenv stuff is all there. svn path=/nixpkgs/branches/stdenv-updates-merge/; revision=10793
2008-02-20 23:02:41 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
blender = callPackage ../applications/misc/blender/2.49.nix {
Adding blender 2.49, additional to the last 'alpha' 2.50 there already was in nixpkgs. I put the alpha in lowPrio too; too many things don't work still, there. svn path=/nixpkgs/trunk/; revision=21701
2010-05-10 11:20:51 +01:00
python = python26Base;
stdenv = stdenv2;
};
blender_2_50 = lowPrio (import ../applications/misc/blender {
Updating blender svn path=/nixpkgs/trunk/; revision=21670
2010-05-08 22:25:56 +01:00
inherit fetchurl cmake mesa gettext libjpeg libpng zlib openal SDL openexr
libsamplerate libtiff ilmbase;
inherit (xlibs) libXi;
python = python31Base;
stdenv = stdenv2;
Adding blender 2.49, additional to the last 'alpha' 2.50 there already was in nixpkgs. I put the alpha in lowPrio too; too many things don't work still, there. svn path=/nixpkgs/trunk/; revision=21701
2010-05-10 11:20:51 +01:00
});
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
bmp = callPackage ../applications/audio/bmp {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gnome) esound libglade;
inherit (gtkLibs) 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 17:26:58 +01:00
bmp_plugin_musepack = callPackage ../applications/audio/bmp-plugins/musepack { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
bmp_plugin_wma = callPackage ../applications/audio/bmp-plugins/wma { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
bvi = callPackage ../applications/editors/bvi { };
svn path=/nixpkgs/trunk/; revision=10233
2008-01-20 22:47:08 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
calibre = callPackage ../applications/misc/calibre {
Adding calibre. This involved also: - Adding podofo - Adding some new python packages - Making new pkgs attributes for python packages to build with python 2.6 - Updating some python packages expressions to allow python 2.6, and not only 2.5. svn path=/nixpkgs/trunk/; revision=19303
2010-01-07 22:47:30 +00:00
python = python26Full;
Adding a new python package to allow calibre preview the books svn path=/nixpkgs/trunk/; revision=20292
2010-02-28 22:55:08 +00:00
inherit (python26Packages) mechanize lxml dateutil cssutils beautifulsoap;
Adding calibre. This involved also: - Adding podofo - Adding some new python packages - Making new pkgs attributes for python packages to build with python 2.6 - Updating some python packages expressions to allow python 2.6, and not only 2.5. svn path=/nixpkgs/trunk/; revision=19303
2010-01-07 22:47:30 +00:00
};
* Removed selectVersion. There's no good reason to write `selectVersion ./foo "bar"' instead of `import ./foo/bar.nix'. * Replaced `with args' with formal function arguments in several packages. * Renamed several files to `default.nix'. As a general rule, version numbers should only be included in the filename when there is a reason to keep multiple versions of a package in Nixpkgs. Otherwise, it just makes it harder to update the package. svn path=/nixpkgs/trunk/; revision=18403
2009-11-18 09:39:59 +00:00
carrier = builderDefsPackage (import ../applications/networking/instant-messengers/carrier/2.5.0.nix) {
all-packages.nix changes for all those updates svn path=/nixpkgs/trunk/; revision=12119
2008-06-16 14:15:55 +01:00
inherit fetchurl stdenv pkgconfig perl perlXMLParser libxml2 openssl nss
gtkspell aspell gettext ncurses avahi dbus dbus_glib python
Switch to GNU Autoconf 2.62. svn path=/nixpkgs/trunk/; revision=12230
2008-07-01 09:31:48 +01:00
libtool automake autoconf;
all-packages.nix changes for all those updates svn path=/nixpkgs/trunk/; revision=12119
2008-06-16 14:15:55 +01:00
GStreamer = gst_all.gstreamer;
inherit (gtkLibs) gtk glib;
inherit (gnome) startupnotification GConf ;
inherit (xlibs) libXScrnSaver scrnsaverproto libX11 xproto kbproto;
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
all-packages.nix changes for all those updates svn path=/nixpkgs/trunk/; revision=12119
2008-06-16 14:15:55 +01: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 17:26:58 +01:00
cddiscid = callPackage ../applications/audio/cd-discid { };
Add cd-discid, a utility to retrieve a CD's CDDB ID. svn path=/nixpkgs/trunk/; revision=11903
2008-05-26 21:18:45 +01:00
- svn path=/nixpkgs/branches/stdenv-updates-merge/; revision=10823
2008-02-22 03:06:12 +00: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 17:26:58 +01:00
cdparanoiaIII = callPackage ../applications/audio/cdparanoia { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cdrtools = callPackage ../applications/misc/cdrtools { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
chatzilla =
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
xulrunnerWrapper {
launcher = "chatzilla";
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
application = callPackage ../applications/networking/irc/chatzilla { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
chrome = callPackage ../applications/networking/browsers/chromium {
chrome 20565 svn path=/nixpkgs/trunk/; revision=18046
2009-10-30 08:45:58 +00:00
inherit (gtkLibs) gtk glib pango atk;
inherit (gnome) GConf;
* added patchelf pre-release 0.6 until it gets stable * updated chrome to latest version svn path=/nixpkgs/trunk/; revision=21836
2010-05-18 13:36:23 +01:00
patchelf = patchelf06;
re-added libjpeg62 for chrome, updated chrome svn path=/nixpkgs/trunk/; revision=19199
2010-01-04 07:47:32 +00:00
libjpeg = libjpeg62;
chrome 20565 svn path=/nixpkgs/trunk/; revision=18046
2009-10-30 08:45:58 +00:00
};
added chromeWrapper, like firefoxWrapper, to allow plugins to work, added previously undefined dependencies on flash plugin svn path=/nixpkgs/trunk/; revision=18050
2009-10-30 12:28:44 +00:00
chromeWrapper = wrapFirefox chrome "chrome" "";
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
cinelerra = callPackage ../applications/video/cinelerra {
added cinelerra (video editing application) svn path=/nixpkgs/trunk/; revision=13068
2008-10-14 15:01:50 +01:00
fftw = fftwSinglePrec;
inherit (gnome) esound;
};
* Get rid of some old Compiz versions. svn path=/nixpkgs/trunk/; revision=16868
2009-08-26 18:04:15 +01:00
compizBase = (builderDefsPackage (import ../applications/window-managers/compiz/0.8.0.nix)) {
Try selecting packages to build based on their being maintained svn path=/nixpkgs/trunk/; revision=16844
2009-08-25 06:46:48 +01:00
inherit lib stringsWithDeps builderDefs;
Use $NIXPKGS_CONFIG to determine whether ghostscript has cups support. svn path=/nixpkgs/trunk/; revision=14275
2009-02-27 13:44:31 +00:00
inherit fetchurl stdenv pkgconfig libpng mesa perl perlXMLParser libxslt gettext
making compiz compile again. builderDefsPackage is used now svn path=/nixpkgs/trunk/; revision=16809
2009-08-22 10:33:38 +01:00
intltool binutils;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (xorg) libXcomposite libXfixes libXdamage libXrandr
libXinerama libICE libSM libXrender xextproto compositeproto fixesproto
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
damageproto randrproto xineramaproto renderproto kbproto xproto libX11
all-packages.nix changes for all the previous commits svn path=/nixpkgs/trunk/; revision=11564
2008-04-11 10:32:27 +01:00
libxcb;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gnome) startupnotification libwnck GConf;
inherit (gtkLibs) gtk;
inherit (gnome) libgnome libgnomeui metacity
glib pango libglade libgtkhtml gtkhtml
libgnomecanvas libgnomeprint
libgnomeprintui gnomepanel;
gnomegtk = gnome.gtk;
inherit librsvg fuse;
inherit dbus dbus_glib;
};
fix compiz-0.6. Now nix-env -q \* should work again. svn path=/nixpkgs/trunk/; revision=16811
2009-08-22 15:50:18 +01:00
compiz = compizBase.passthru.function (x : x // {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
extraConfigureFlags = getConfig ["compiz" "extraConfigureFlags"] [];
fix compiz-0.6. Now nix-env -q \* should work again. svn path=/nixpkgs/trunk/; revision=16811
2009-08-22 15:50:18 +01:00
});
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
compizFusion = callPackage ../applications/window-managers/compiz-fusion {
Compiz-Fusion 0.7.8 svn path=/nixpkgs/trunk/; revision=13117
2008-10-26 11:58:42 +00:00
version = getConfig ["compizFusion" "version"] "0.7.8";
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gnome) startupnotification libwnck GConf;
inherit (gtkLibs) gtk;
inherit (gnome) libgnome libgnomeui metacity
glib pango libglade libgtkhtml gtkhtml
libgnomecanvas libgnomeprint
libgnomeprintui gnomepanel gnomedesktop;
gnomegtk = gnome.gtk;
};
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
compizExtra = callPackage ../applications/window-managers/compiz/extra.nix {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gnome) GConf;
inherit (gtkLibs) gtk;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
cinepaint = callPackage ../applications/graphics/cinepaint {
Adding cinepaint 0.22.1 and as a dependency, also fltk 1.1.9 svn path=/nixpkgs/trunk/; revision=14841
2009-04-02 16:20:19 +01:00
inherit (gtkLibs) gtk glib;
fltk = fltk11;
};
* Removed selectVersion. There's no good reason to write `selectVersion ./foo "bar"' instead of `import ./foo/bar.nix'. * Replaced `with args' with formal function arguments in several packages. * Renamed several files to `default.nix'. As a general rule, version numbers should only be included in the filename when there is a reason to keep multiple versions of a package in Nixpkgs. Otherwise, it just makes it harder to update the package. svn path=/nixpkgs/trunk/; revision=18403
2009-11-18 09:39:59 +00:00
codeville = builderDefsPackage (import ../applications/version-management/codeville/0.8.0.nix) {
Adding possibility to have rich Python installation for development but use only the base one for, say, OpenOffice (and be able to use buildfarm). Codeville and Bazaar use the rich variant - they do have some use for it.. svn path=/nixpkgs/trunk/; revision=13075
2008-10-15 21:01:39 +01:00
inherit makeWrapper;
python = pythonFull;
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
Added codeville - a distributed revision control system with special efforts spent on merging. Heh, efforts into RCS availability seem to have side effects on Python side, too.. svn path=/nixpkgs/trunk/; revision=11891
2008-05-26 08:47:07 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
comical = callPackage ../applications/graphics/comical {
Setting wxGTK to use the old gtk libs. Until wxGTK 2.8.11 they will not fix a symbol clash with glib 2.21. So we keep with glib 2.20. I also changed the default wxGTK from 2.6 to 2.8, caring so no hash is changed due to this change. Some packages using 2.6 may well build with 2.8, so we can try updating them for another commit. svn path=/nixpkgs/trunk/; revision=18133
2009-11-05 13:29:52 +00:00
wxGTK = wxGTK26;
Adding comical-0.8 svn path=/nixpkgs/trunk/; revision=14016
2009-02-09 20:44:26 +00:00
};
conkeror: New nixpkg. svn path=/nixpkgs/trunk/; revision=21296
2010-04-24 18:34:58 +01:00
conkeror = xulrunnerWrapper {
launcher = "conkeror";
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
application = callPackage ../applications/networking/browsers/conkeror { };
conkeror: New nixpkg. svn path=/nixpkgs/trunk/; revision=21296
2010-04-24 18:34:58 +01:00
};
Added Cuneiform OCR. Works somehow.. svn path=/nixpkgs/trunk/; revision=14015
2009-02-09 20:37:11 +00: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 17:26:58 +01:00
cvs = callPackage ../applications/version-management/cvs { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cvsps = callPackage ../applications/version-management/cvsps { };
Add CVSps, needed for instance by `git-cvsimport'. svn path=/nixpkgs/trunk/; revision=11094
2008-03-13 10:02:57 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cvs2svn = callPackage ../applications/version-management/cvs2svn { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
d4x = callPackage ../applications/misc/d4x {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gtkLibs) gtk glib;
};
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
Switched the default version of ghc and Haskell Platform to 6.12.3 and 2010.2.0.0. svn path=/nixpkgs/trunk/; revision=22715
2010-07-22 19:47:59 +01:00
darcs = haskellPackages.darcs;
added darcs-2.0.0pre svn path=/nixpkgs/trunk/; revision=10564
2008-02-09 13:52:41 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
dia = callPackage ../applications/graphics/dia {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gtkLibs) gtk 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 17:26:58 +01:00
djvulibre = callPackage ../applications/misc/djvulibre { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
djview4 = callPackage ../applications/graphics/djview { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dmenu = callPackage ../applications/misc/dmenu { };
Added: * dmenu * gftp * micropolis * byacc as a build-time dependency for micropolis contributed by baldo <baldo@quimby.lan> svn path=/nixpkgs/trunk/; revision=12526
2008-08-06 21:39:01 +01:00
Added DataMatrix (2D bar code) processing utilities svn path=/nixpkgs/trunk/; revision=13281
2008-11-13 13:31:10 +00:00
dmtx = builderDefsPackage (import ../tools/graphics/dmtx) {
subversion: updated to version 1.6.0 svn path=/nixpkgs/trunk/; revision=14682
2009-03-24 10:31:39 +00:00
inherit libpng libtiff libjpeg imagemagick librsvg
pkgs/applications/editors/emacs-modes/magit: updated to version magit-0.7-94-gbf42bf8 Magit has seen plenty of development since version 0.7, but for some reason there haven't been any new releases. This version bump updates the expression to build a current version of Magit directly from the Git repository. This change adds buildInputs 'autoconf' and 'automake'. These tools are required only because we aren't building from a proper release tarball. Once version 0.8 comes out, these dependencies can be dropped again. svn path=/nixpkgs/trunk/; revision=20650
2010-03-16 12:13:40 +00:00
pkgconfig bzip2 zlib libtool freetype fontconfig
DMTX now needs libjasper.. pass that lib to dmtx svn path=/nixpkgs/trunk/; revision=21852
2010-05-18 22:15:13 +01:00
ghostscript jasper;
DataMatrix update svn path=/nixpkgs/trunk/; revision=14607
2009-03-19 13:59:00 +00:00
inherit (xlibs) libX11;
Added DataMatrix (2D bar code) processing utilities svn path=/nixpkgs/trunk/; revision=13281
2008-11-13 13:31:10 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dvdauthor = callPackage ../applications/video/dvdauthor { };
added dvdauthor svn path=/nixpkgs/trunk/; revision=13766
2009-01-14 16:23:06 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
dwm = callPackage ../applications/window-managers/dwm {
Updating dwm, and allowing users set their own patches to configure it. svn path=/nixpkgs/trunk/; revision=20437
2010-03-05 21:49:29 +00:00
patches = getConfig [ "dwm" "patches" ] [];
maudeUnstable: updated full-maude to latest alpha release svn path=/nixpkgs/trunk/; revision=13017
2008-10-09 11:10:49 +01:00
};
add window-manager dwm contributed by viric svn path=/nixpkgs/trunk/; revision=12687
2008-08-21 21:44:08 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
eaglemode = callPackage ../applications/misc/eaglemode { };
eclipse-new expression (update of eclipse_classic_src) It supports now insntalling some plugins (however the eclipse path will be copied once) You can still just copy the whole store path to you home directory to install additional plugins using update sites svn path=/nixpkgs/trunk/; revision=13121
2008-10-26 17:45:14 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
eclipse = callPackage ../applications/editors/eclipse {
* Removed a lot of old Eclipse versions. * Cleaned up the Eclipse classic expression a bit (e.g. use makeWrapper). Also fall back to GTK 2.16 to fix some GUI glitches. svn path=/nixpkgs/trunk/; revision=18485
2009-11-20 15:19:00 +00:00
# GTK 2.18 gives glitches such as mouse clicks on buttons not
# working correctly.
inherit (gtkLibs216) glib gtk;
Enabled my eclipse package again, since I want to have eclipse installed when typing nix-env -i. BTW. the eclipse plugins can be installed this way either svn path=/nixpkgs/trunk/; revision=18074
2009-11-03 11:00:18 +00:00
};
adding Eclipse note, readding older version. adding eclipseLatest top level name svn path=/nixpkgs/trunk/; revision=21684
2010-05-09 15:17:21 +01:00
eclipseLatest = eclipse.override { version = "latest"; };
Enabled my eclipse package again, since I want to have eclipse installed when typing nix-env -i. BTW. the eclipse plugins can be installed this way either svn path=/nixpkgs/trunk/; revision=18074
2009-11-03 11:00:18 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ed = callPackage ../applications/editors/ed { };
Move GNU ed, add meta-information. svn path=/nixpkgs/trunk/; revision=11715
2008-04-25 17:13:36 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
elinks = callPackage ../applications/networking/browsers/elinks { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
elvis = callPackage ../applications/editors/elvis { };
Adding elvis, although I can't see the characters in an xterm with black background svn path=/nixpkgs/trunk/; revision=15098
2009-04-16 20:28:42 +01:00
* Remove some old Emacs versions. svn path=/nixpkgs/trunk/; revision=18470
2009-11-19 17:36:43 +00:00
emacs = emacs23;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
emacs22 = callPackage ../applications/editors/emacs-22 {
* Bring back Emacs 22 by request from Ludovic. svn path=/nixpkgs/trunk/; revision=18529
2009-11-22 16:29:15 +00:00
inherit (gtkLibs) gtk;
xaw3dSupport = getPkgConfig "emacs" "xaw3dSupport" false;
gtkGUI = getPkgConfig "emacs" "gtkSupport" true;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
emacs23 = callPackage ../applications/editors/emacs-23 {
pkgs/top-level/all-packages.nix, pkgs/applications/editors/emacs-23: prefer makeOverridable over getPkgConfig to customize GNU Emacs Changed 'emacs23' expression to allow for argument overriding instead of relying on getPkgConfig. While I was at it, I also simplified the actual build expression a bit. svn path=/nixpkgs/trunk/; revision=21873
2010-05-19 13:26:21 +01:00
# use override to select the appropriate gui toolkit
libXaw = if stdenv.isDarwin then xlibs.libXaw else null;
Xaw3d = null;
* I assume building Emacs without GTK was only supposed to happen on Darwin. svn path=/nixpkgs/trunk/; revision=22048
2010-05-28 14:59:57 +01:00
gtk = if stdenv.isDarwin then null else gtkLibs.gtk;
pkgs/top-level/all-packages.nix, pkgs/applications/editors/emacs-23: prefer makeOverridable over getPkgConfig to customize GNU Emacs Changed 'emacs23' expression to allow for argument overriding instead of relying on getPkgConfig. While I was at it, I also simplified the actual build expression a bit. svn path=/nixpkgs/trunk/; revision=21873
2010-05-19 13:26:21 +01:00
# TODO: these packages don't build on Darwin.
gconf = if stdenv.isDarwin then null else gnome.GConf;
librsvg = if stdenv.isDarwin then null else librsvg;
GNU Emacs 23.1. svn path=/nixpkgs/trunk/; revision=16529
2009-07-31 23:25:05 +01:00
};
emacsSnapshot = lowPrio (import ../applications/editors/emacs-snapshot {
GNU Emacs live from CVS. svn path=/nixpkgs/trunk/; revision=14107
2009-02-17 21:05:52 +00:00
inherit fetchcvs stdenv ncurses pkgconfig x11 Xaw3d
GNU Emacs 23.x: D-Bus support. svn path=/nixpkgs/trunk/; revision=14207
2009-02-23 16:06:59 +00:00
libpng libjpeg libungif libtiff texinfo dbus
GNU Emacs live from CVS. svn path=/nixpkgs/trunk/; revision=14107
2009-02-17 21:05:52 +00:00
autoconf automake;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (xlibs) libXaw libXpm libXft;
inherit (gtkLibs) gtk;
emacs: Lower prio of emacs-23 and generally get options from ${NIXPKGS_CONFIG}. By default, 'nix-env --install emacs' will install Emacs 22.3, which is the latest stable release. Furthermore, the following options are now supported: emacs = { xawSupport = false; # used only by emacs 23 xaw3dSupport = false; gtkSupport = true; xftSupport = true; # used only by emacs 23 }; svn path=/nixpkgs/trunk/; revision=12922
2008-09-25 22:38:16 +01:00
xawSupport = getPkgConfig "emacs" "xawSupport" false;
xaw3dSupport = getPkgConfig "emacs" "xaw3dSupport" false;
gtkGUI = getPkgConfig "emacs" "gtkSupport" true;
xftSupport = getPkgConfig "emacs" "xftSupport" true;
GNU Emacs 23.x: D-Bus support. svn path=/nixpkgs/trunk/; revision=14207
2009-02-23 16:06:59 +00:00
dbusSupport = getPkgConfig "emacs" "dbusSupport" true;
emacs: Lower prio of emacs-23 and generally get options from ${NIXPKGS_CONFIG}. By default, 'nix-env --install emacs' will install Emacs 22.3, which is the latest stable release. Furthermore, the following options are now supported: emacs = { xawSupport = false; # used only by emacs 23 xaw3dSupport = false; gtkSupport = true; xftSupport = true; # used only by emacs 23 }; svn path=/nixpkgs/trunk/; revision=12922
2008-09-25 22:38:16 +01:00
});
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
svn path=/nixpkgs/trunk/; revision=22880
2010-08-02 17:01:55 +01:00
emacsPackages = emacs: self: let callPackage = newScope self; in rec {
emacsPackages should inherit emacs to add the correct version to the inner scope svn path=/nixpkgs/trunk/; revision=23159
2010-08-13 08:55:57 +01: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 17:26:58 +01:00
bbdb = callPackage ../applications/editors/emacs-modes/bbdb { };
Rename `emacsUnicode' to `emacs23'. svn path=/nixpkgs/trunk/; revision=16073
2009-06-28 00:09:21 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cedet = callPackage ../applications/editors/emacs-modes/cedet { };
Group Emacs packages in an `emacsPackages' function. This avoids problem such as bytecode incompatibilies (e.g., between GNU Emacs 22 and 23), API changes. It would also allow packages to be built with different emacsen (S(X)Emacs, etc.). svn path=/nixpkgs/trunk/; revision=16324
2009-07-10 17:17:06 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cua = callPackage ../applications/editors/emacs-modes/cua { };
Group Emacs packages in an `emacsPackages' function. This avoids problem such as bytecode incompatibilies (e.g., between GNU Emacs 22 and 23), API changes. It would also allow packages to be built with different emacsen (S(X)Emacs, etc.). svn path=/nixpkgs/trunk/; revision=16324
2009-07-10 17:17:06 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ecb = callPackage ../applications/editors/emacs-modes/ecb { };
Group Emacs packages in an `emacsPackages' function. This avoids problem such as bytecode incompatibilies (e.g., between GNU Emacs 22 and 23), API changes. It would also allow packages to be built with different emacsen (S(X)Emacs, etc.). svn path=/nixpkgs/trunk/; revision=16324
2009-07-10 17:17:06 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jabber = callPackage ../applications/editors/emacs-modes/jabber { };
applications/editors/emacs-modes/jabber: New nixbuild. svn path=/nixpkgs/trunk/; revision=21806
2010-05-16 21:32:21 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
emacsSessionManagement = callPackage ../applications/editors/emacs-modes/session-management-for-emacs { };
Group Emacs packages in an `emacsPackages' function. This avoids problem such as bytecode incompatibilies (e.g., between GNU Emacs 22 and 23), API changes. It would also allow packages to be built with different emacsen (S(X)Emacs, etc.). svn path=/nixpkgs/trunk/; revision=16324
2009-07-10 17:17:06 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
emacsw3m = callPackage ../applications/editors/emacs-modes/emacs-w3m { };
Group Emacs packages in an `emacsPackages' function. This avoids problem such as bytecode incompatibilies (e.g., between GNU Emacs 22 and 23), API changes. It would also allow packages to be built with different emacsen (S(X)Emacs, etc.). svn path=/nixpkgs/trunk/; revision=16324
2009-07-10 17:17:06 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
emms = callPackage ../applications/editors/emacs-modes/emms { };
Add Emacs-w3m, an Emacs interface to the W3M web browser. svn path=/nixpkgs/trunk/; revision=16287
2009-07-09 16:56:40 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
jdee = callPackage ../applications/editors/emacs-modes/jdee {
Group Emacs packages in an `emacsPackages' function. This avoids problem such as bytecode incompatibilies (e.g., between GNU Emacs 22 and 23), API changes. It would also allow packages to be built with different emacsen (S(X)Emacs, etc.). svn path=/nixpkgs/trunk/; revision=16324
2009-07-10 17:17:06 +01:00
# Requires Emacs 23, for `avl-tree'.
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
stratego = callPackage ../applications/editors/emacs-modes/stratego { };
* stratego-mode for emacs svn path=/nixpkgs/trunk/; revision=16910
2009-09-01 15:27:24 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
haskellMode = callPackage ../applications/editors/emacs-modes/haskell { };
Group Emacs packages in an `emacsPackages' function. This avoids problem such as bytecode incompatibilies (e.g., between GNU Emacs 22 and 23), API changes. It would also allow packages to be built with different emacsen (S(X)Emacs, etc.). svn path=/nixpkgs/trunk/; revision=16324
2009-07-10 17:17:06 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
hol_light_mode = callPackage ../applications/editors/emacs-modes/hol_light { };
Add HOL Light and its dependencies. Add pkgs/applications/science/logic/hol_light and pkgs/applications/science/emacs-modes/hol_light Some functionalities of HOL Light requires the compiled sources of OCaml. For now we provide a new package ocaml_with_sources. After this shuold be merged with the current version of OCaml already present in nixpkgs. svn path=/nixpkgs/trunk/; revision=20008
2010-02-15 11:00:02 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
magit = callPackage ../applications/editors/emacs-modes/magit { };
Group Emacs packages in an `emacsPackages' function. This avoids problem such as bytecode incompatibilies (e.g., between GNU Emacs 22 and 23), API changes. It would also allow packages to be built with different emacsen (S(X)Emacs, etc.). svn path=/nixpkgs/trunk/; revision=16324
2009-07-10 17:17:06 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
maudeMode = callPackage ../applications/editors/emacs-modes/maude { };
Group Emacs packages in an `emacsPackages' function. This avoids problem such as bytecode incompatibilies (e.g., between GNU Emacs 22 and 23), API changes. It would also allow packages to be built with different emacsen (S(X)Emacs, etc.). svn path=/nixpkgs/trunk/; revision=16324
2009-07-10 17:17:06 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
nxml = callPackage ../applications/editors/emacs-modes/nxml { };
Group Emacs packages in an `emacsPackages' function. This avoids problem such as bytecode incompatibilies (e.g., between GNU Emacs 22 and 23), API changes. It would also allow packages to be built with different emacsen (S(X)Emacs, etc.). svn path=/nixpkgs/trunk/; revision=16324
2009-07-10 17:17:06 +01:00
Give Org-Mode a high priority. svn path=/nixpkgs/trunk/; revision=22694
2010-07-22 09:59:46 +01:00
# This is usually a newer version of Org-Mode than that found in GNU Emacs, so
# we want it to have higher precedence.
org = hiPrio (import ../applications/editors/emacs-modes/org {
Add upstream Org-Mode. svn path=/nixpkgs/trunk/; revision=22693
2010-07-22 09:59:12 +01:00
inherit fetchurl stdenv emacs texinfo;
Give Org-Mode a high priority. svn path=/nixpkgs/trunk/; revision=22694
2010-07-22 09:59:46 +01:00
});
Add upstream Org-Mode. svn path=/nixpkgs/trunk/; revision=22693
2010-07-22 09:59:12 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
prologMode = callPackage ../applications/editors/emacs-modes/prolog { };
Add expression for ProofGeneral svn path=/nixpkgs/trunk/; revision=18904
2009-12-11 16:18:27 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
proofgeneral = callPackage ../applications/editors/emacs-modes/proofgeneral { };
Group Emacs packages in an `emacsPackages' function. This avoids problem such as bytecode incompatibilies (e.g., between GNU Emacs 22 and 23), API changes. It would also allow packages to be built with different emacsen (S(X)Emacs, etc.). svn path=/nixpkgs/trunk/; revision=16324
2009-07-10 17:17:06 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
quack = callPackage ../applications/editors/emacs-modes/quack { };
Add Emacs Scala-Mode. svn path=/nixpkgs/trunk/; revision=17904
2009-10-20 16:12:29 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
remember = callPackage ../applications/editors/emacs-modes/remember { };
pkgs/applications/editors/emacs-modes/rudel: added rudel 0.2-4 A collaborative editing environment for GNU Emacs. svn path=/nixpkgs/trunk/; revision=22733
2010-07-26 14:41:03 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
rudel = callPackage ../applications/editors/emacs-modes/rudel { };
scalaMode = callPackage ../applications/editors/emacs-modes/scala-mode { };
svn path=/nixpkgs/trunk/; revision=22880
2010-08-02 17:01:55 +01:00
};
Add EMMS, the Emacs Multimedia System. svn path=/nixpkgs/trunk/; revision=12675
2008-08-21 09:58:51 +01:00
svn path=/nixpkgs/trunk/; revision=22880
2010-08-02 17:01:55 +01:00
emacs22Packages = emacsPackages emacs22 pkgs.emacs22Packages;
emacs23Packages = emacsPackages emacs23 pkgs.emacs23Packages;
Group Emacs packages in an `emacsPackages' function. This avoids problem such as bytecode incompatibilies (e.g., between GNU Emacs 22 and 23), API changes. It would also allow packages to be built with different emacsen (S(X)Emacs, etc.). svn path=/nixpkgs/trunk/; revision=16324
2009-07-10 17:17:06 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
epdfview = callPackage ../applications/misc/epdfview {
applications/misc/epdfview: New package. svn path=/nixpkgs/trunk/; revision=19498
2010-01-17 01:39:29 +00:00
inherit (gtkLibs) gtk;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
evince = callPackage ../applications/misc/evince {
Add Evince, GNOME's document viewer (PS, PDF, DVI, DjVu, TIFF, etc.). Currently, a few theme icons provided by Evince are not found. This is possibly due to the lack of an `index.theme' file under `share/evince/icons', but there's no rule to make it. svn path=/nixpkgs/trunk/; revision=12434
2008-07-27 11:24:08 +01:00
inherit (gnome) gnomedocutils gnomeicontheme libgnome
* Added gnome-icon-theme. svn path=/nixpkgs/branches/xorg-7.5/; revision=18118
2009-11-04 21:44:01 +00:00
libgnomeui libglade glib gtk scrollkeeper gnome_keyring;
Add Evince, GNOME's document viewer (PS, PDF, DVI, DjVu, TIFF, etc.). Currently, a few theme icons provided by Evince are not found. This is possibly due to the lack of an `index.theme' file under `share/evince/icons', but there's no rule to make it. svn path=/nixpkgs/trunk/; revision=12434
2008-07-27 11:24:08 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
exrdisplay = callPackage ../applications/graphics/exrdisplay {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
fltk = fltk20;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
fbpanel = callPackage ../applications/window-managers/fbpanel {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gtkLibs) gtk;
};
fetchmail = import ../applications/misc/fetchmail {
svn path=/nixpkgs/trunk/; revision=10828
2008-02-22 10:12:01 +00:00
inherit stdenv fetchurl openssl;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
fossil = callPackage ../applications/version-management/fossil { };
Add package for Fossil svn path=/nixpkgs/trunk/; revision=21746
2010-05-12 14:17:19 +01:00
adding gis system grass (graphviz 3d is not supported yet) svn path=/nixpkgs/trunk/; revision=22131
2010-06-03 16:19:59 +01: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;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
grip = callPackage ../applications/misc/grip {
adding grip, a gui rip application (segfaults on amd64 ?) svn path=/nixpkgs/trunk/; revision=17305
2009-09-20 18:01:31 +01:00
inherit (gtkLibs) gtk glib;
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 17:26:58 +01:00
wavesurfer = callPackage ../applications/misc/audio/wavesurfer { };
added wavesurfer (sound analysis tool) and its dependency snack (tcl /python sound tool library) svn path=/nixpkgs/trunk/; revision=12904
2008-09-24 01:42:06 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
wireshark = callPackage ../applications/networking/sniffers/wireshark {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gtkLibs) gtk;
};
pkgs/top-level/all-packages.nix: strip trailing white space svn path=/nixpkgs/trunk/; revision=21416
2010-04-29 09:54:02 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
wvdial = callPackage ../os-specific/linux/wvdial { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
Adding fbida, framebuffer image viewer svn path=/nixpkgs/trunk/; revision=16571
2009-08-04 08:14:43 +01:00
fbida = builderDefsPackage ../applications/graphics/fbida {
inherit libjpeg libexif giflib libtiff libpng
imagemagick ghostscript which curl pkgconfig
freetype fontconfig;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
fdupes = callPackage ../tools/misc/fdupes { };
added fdupes-1.40 (utility to find duplicate files) provided by Marco Maggesi svn path=/nixpkgs/trunk/; revision=13134
2008-10-28 11:56:43 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
feh = callPackage ../applications/graphics/feh { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Fix evaluation problems. svn path=/nixpkgs/branches/x-updates/; revision=22668
2010-07-19 23:24:26 +01:00
firefox = firefox36Pkgs.firefox;
* Make Firefox 3.6 the default. svn path=/nixpkgs/branches/x-updates/; revision=22653
2010-07-19 00:23:16 +01:00
firefoxWrapper = firefox36Wrapper;
* Build Firefox 3 in the channel. svn path=/nixpkgs/trunk/; revision=12378
2008-07-18 11:41:27 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
firefox35Pkgs = callPackage ../applications/networking/browsers/firefox/3.5.nix {
All-packages.nix: update firefox beta, erlang svn path=/nixpkgs/trunk/; revision=15453
2009-05-05 16:46:24 +01:00
inherit (gtkLibs) gtk pango;
inherit (gnome) libIDL;
* Added Firefox 3.6. It's not entirely stable yet though. In particular it segfaults with the `-P' option. svn path=/nixpkgs/trunk/; revision=19606
2010-01-21 22:23:59 +00:00
};
All-packages.nix: update firefox beta, erlang svn path=/nixpkgs/trunk/; revision=15453
2009-05-05 16:46:24 +01:00
* Fix evaluation problems. svn path=/nixpkgs/branches/x-updates/; revision=22668
2010-07-19 23:24:26 +01:00
firefox35Wrapper = wrapFirefox firefox35Pkgs.firefox "firefox" "";
* Xulrunner/Firefox 3.5: build with --with-system-nss. svn path=/nixpkgs/trunk/; revision=16186
2009-07-06 12:42:21 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
firefox36Pkgs = callPackage ../applications/networking/browsers/firefox/3.6.nix {
* Added Firefox 3.6. It's not entirely stable yet though. In particular it segfaults with the `-P' option. svn path=/nixpkgs/trunk/; revision=19606
2010-01-21 22:23:59 +00:00
inherit (gtkLibs) gtk pango;
inherit (gnome) libIDL;
};
* Fix evaluation problems. svn path=/nixpkgs/branches/x-updates/; revision=22668
2010-07-19 23:24:26 +01:00
firefox36Wrapper = wrapFirefox firefox36Pkgs.firefox "firefox" "";
pkgs/top-level/all-packages.nix: stripped trailing whitespace svn path=/nixpkgs/trunk/; revision=19670
2010-01-26 14:53:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
flac = callPackage ../applications/audio/flac { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Build Firefox 3 on top of xulrunner. This significantly reduces the build time and makes Firefox itself only 3 megabytes or so large. * Fixed building the mplayerplug-in on Firefox 3. Since the latter now uses xulrunner, we no longer need the firefox3Xul hack. TODO: do this for Icecat as well. svn path=/nixpkgs/trunk/; revision=13160
2008-10-30 13:00:50 +00:00
flashplayer = flashplayer10;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
Trying to reinstate the meta-based Hydra builds svn path=/nixpkgs/trunk/; revision=16883
2009-08-28 07:29:21 +01:00
flashplayer9 = (
Flash player also has assertions.. svn path=/nixpkgs/trunk/; revision=16848
2009-08-25 07:11:22 +01:00
import ../applications/networking/browsers/mozilla-plugins/flashplayer-9 {
added chromeWrapper, like firefoxWrapper, to allow plugins to work, added previously undefined dependencies on flash plugin svn path=/nixpkgs/trunk/; revision=18050
2009-10-30 12:28:44 +00:00
inherit fetchurl stdenv zlib alsaLib nss nspr fontconfig freetype expat;
* Added Firefox 3.6. It's not entirely stable yet though. In particular it segfaults with the `-P' option. svn path=/nixpkgs/trunk/; revision=19606
2010-01-21 22:23:59 +00:00
inherit (xlibs) libX11 libXext libXrender libXt;
added chromeWrapper, like firefoxWrapper, to allow plugins to work, added previously undefined dependencies on flash plugin svn path=/nixpkgs/trunk/; revision=18050
2009-10-30 12:28:44 +00:00
inherit (gtkLibs) gtk glib pango atk;
Flash player also has assertions.. svn path=/nixpkgs/trunk/; revision=16848
2009-08-25 07:11:22 +01:00
});
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
Trying to reinstate the meta-based Hydra builds svn path=/nixpkgs/trunk/; revision=16883
2009-08-28 07:29:21 +01:00
flashplayer10 = (
Flash player also has assertions.. svn path=/nixpkgs/trunk/; revision=16848
2009-08-25 07:11:22 +01:00
import ../applications/networking/browsers/mozilla-plugins/flashplayer-10 {
added chromeWrapper, like firefoxWrapper, to allow plugins to work, added previously undefined dependencies on flash plugin svn path=/nixpkgs/trunk/; revision=18050
2009-10-30 12:28:44 +00:00
inherit fetchurl stdenv zlib alsaLib curl nss nspr fontconfig freetype expat;
inherit (xlibs) libX11 libXext libXrender libXt ;
inherit (gtkLibs) gtk glib pango atk;
adding debug version of i686 flash player. See comments svn path=/nixpkgs/trunk/; revision=19195
2010-01-04 07:44:24 +00:00
debug = getConfig ["flashplayer" "debug"] false;
Flash player also has assertions.. svn path=/nixpkgs/trunk/; revision=16848
2009-08-25 07:11:22 +01:00
});
* Added Adobe Flash Player 10. svn path=/nixpkgs/trunk/; revision=13085
2008-10-16 14:36:27 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
flite = callPackage ../applications/misc/flite { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
freemind = callPackage ../applications/misc/freemind {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00: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 17:26:58 +01:00
freepv = callPackage ../applications/graphics/freepv { };
Adding freepv, without its mozilla plug-in. svn path=/nixpkgs/trunk/; revision=14954
2009-04-08 21:05:59 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xfontsel = callPackage ../applications/misc/xfontsel { };
xlsfonts = callPackage ../applications/misc/xlsfonts { };
Adding xfontsel. A bit hacky (to work well, it requires copying its app-defaults to $HOME) As app-defaults should be installed with the libXt (maybe it's libXt which loads them), and stracing that is the place where the code looks for app-defaults (the libXt store path), I don't know of any better solution in nixpkgs by now. svn path=/nixpkgs/trunk/; revision=19092
2009-12-24 14:48:36 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
fspot = callPackage ../applications/graphics/f-spot {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gnome) libgnome libgnomeui;
gtksharp = gtksharp1;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gimp = callPackage ../applications/graphics/gimp {
* GIMP updated to 2.6.7. It no longer needs libgtkhtml. svn path=/nixpkgs/branches/xorg-7.5/; revision=18117
2009-11-04 21:28:11 +00:00
inherit (gnome) gtk libart_lgpl;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
pkgs/applications/editors/emacs-modes/prolog: initial version of prolog-mode for Emacs svn path=/nixpkgs/trunk/; revision=18675
2009-11-27 17:40:56 +00:00
Adding the GAP gimp plugin, and making nix-env recurse into the gimp plugins attribute set. svn path=/nixpkgs/trunk/; revision=19936
2010-02-11 15:08:05 +00:00
gimpPlugins = recurseIntoAttrs (import ../applications/graphics/gimp/plugins {
inherit pkgs gimp;
});
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
adding gitAttr now containing qgit, stgit, topGit, hg2git updating gitGit (git dev version), adding qgit-git (dev version) svn path=/nixpkgs/trunk/; revision=13816
2009-01-20 22:15:42 +00:00
gitAndTools = recurseIntoAttrs (import ../applications/version-management/git-and-tools {
inherit pkgs;
});
git = gitAndTools.git;
Add `gitFull'. svn path=/nixpkgs/trunk/; revision=19525
2010-01-18 16:07:44 +00:00
gitFull = gitAndTools.gitFull;
new: qgit is a qt-based graphical front-end for git svn path=/nixpkgs/trunk/; revision=12299
2008-07-07 12:48:24 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gnucash = callPackage ../applications/office/gnucash {
Add GnuCash. svn path=/nixpkgs/trunk/; revision=17551
2009-09-30 14:11:17 +01:00
inherit (gnome) gtk glib libglade libgnomeui libgtkhtml gtkhtml
libgnomeprint;
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 17:26:58 +01:00
qcad = callPackage ../applications/misc/qcad { };
adding qcad-2.0.5.0 svn path=/nixpkgs/trunk/; revision=14744
2009-03-28 02:25:03 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
qjackctl = callPackage ../applications/audio/qjackctl {
added qjackctl svn path=/nixpkgs/trunk/; revision=12650
2008-08-18 17:03:21 +01:00
qt4 = qt4;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gkrellm = callPackage ../applications/misc/gkrellm {
Add GKrellM, a graphical system monitor. svn path=/nixpkgs/trunk/; revision=10660
2008-02-13 16:38:33 +00:00
inherit (gtkLibs) glib gtk;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gnash = callPackage ../applications/video/gnash {
GNU Gnash 0.8.2, Agg 2.5. svn path=/nixpkgs/trunk/; revision=11030
2008-03-10 09:48:17 +00:00
inherit (gtkLibs) glib gtk;
Gnash: Use gst-ffmpeg and set the right `GST_PLUGIN_PATH'. This makes viewing YouTube videos work out-of-the-box! svn path=/nixpkgs/trunk/; revision=13256
2008-11-12 08:37:39 +00:00
inherit (gst_all) gstreamer gstPluginsBase gstFfmpeg;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gnome_mplayer = callPackage ../applications/video/gnome-mplayer {
* Added gecko-mediaplayer, a browser plugin that uses gnome-mplayer to play video. Seems to be more stable than mplayerplug-in. svn path=/nixpkgs/trunk/; revision=16379
2009-07-15 21:34:08 +01:00
inherit (gtkLibs) glib gtk;
inherit (gnome) GConf;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gnunet = callPackage ../applications/networking/p2p/gnunet {
Add GNUnet, GNU's anonymous peer-to-peer communication framework. svn path=/nixpkgs/trunk/; revision=12699
2008-08-24 19:48:09 +01:00
inherit (gnome) gtk libglade;
gtkSupport = getConfig [ "gnunet" "gtkSupport" ] 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 17:26:58 +01:00
gocr = callPackage ../applications/graphics/gocr { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gphoto2 = callPackage ../applications/misc/gphoto2 { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
Adding Gphoto2FS - filesystem for attached cameras svn path=/nixpkgs/trunk/; revision=16841
2009-08-24 22:35:45 +01:00
gphoto2fs = builderDefsPackage ../applications/misc/gphoto2/gphotofs.nix {
* Replace some "inherit (gtkLibs) glib" statements with "inherit glib". svn path=/nixpkgs/trunk/; revision=18013
2009-10-29 11:43:02 +00:00
inherit libgphoto2 fuse pkgconfig glib;
Adding Gphoto2FS - filesystem for attached cameras svn path=/nixpkgs/trunk/; revision=16841
2009-08-24 22:35:45 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
graphicsmagick = callPackage ../applications/graphics/graphicsmagick { };
Adding GraphicsMagick svn path=/nixpkgs/trunk/; revision=20383
2010-03-04 14:44:47 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
graphicsmagick137 = callPackage ../applications/graphics/graphicsmagick/1.3.7.nix { };
Adding graphicsmagick 1.3.7 for octave imread() and alike to work. svn path=/nixpkgs/trunk/; revision=20390
2010-03-04 16:41:14 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gtkpod = callPackage ../applications/audio/gtkpod {
Adding gtkpod, and fixing libgpod meta info. svn path=/nixpkgs/trunk/; revision=15016
2009-04-13 16:41:10 +01:00
inherit (gtkLibs) gtk glib;
inherit (gnome) libglade;
};
Added qrencode and qrdecode - tools for QR code. Qrdecode behaves strangely (Debian package does the same, so probably upstream bug) svn path=/nixpkgs/trunk/; revision=13304
2008-11-15 17:54:09 +00:00
qrdecode = builderDefsPackage (import ../tools/graphics/qrdecode) {
inherit libpng libcv;
};
qrencode = builderDefsPackage (import ../tools/graphics/qrencode) {
inherit libpng pkgconfig;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gecko_mediaplayer = callPackage ../applications/networking/browsers/mozilla-plugins/gecko-mediaplayer {
* Added gecko-mediaplayer, a browser plugin that uses gnome-mplayer to play video. Seems to be more stable than mplayerplug-in. svn path=/nixpkgs/trunk/; revision=16379
2009-07-15 21:34:08 +01:00
inherit (gnome) GConf;
* Fix evaluation problems. svn path=/nixpkgs/branches/x-updates/; revision=22668
2010-07-19 23:24:26 +01:00
browser = firefox;
* Added gecko-mediaplayer, a browser plugin that uses gnome-mplayer to play video. Seems to be more stable than mplayerplug-in. svn path=/nixpkgs/trunk/; revision=16379
2009-07-15 21:34:08 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
geeqie = callPackage ../applications/graphics/geeqie {
Add Geeqie, a GQview fork. svn path=/nixpkgs/trunk/; revision=18613
2009-11-25 08:58:42 +00:00
inherit (gtkLibs) gtk;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gqview = callPackage ../applications/graphics/gqview {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gtkLibs) gtk;
};
* Use callPackage_i686 for i686-only packages. svn path=/nixpkgs/trunk/; revision=23113
2010-08-11 14:25:30 +01:00
googleearth = callPackage_i686 ../applications/misc/googleearth { };
Adding google earth. svn path=/nixpkgs/trunk/; revision=15014
2009-04-13 16:40:51 +01:00
A top-level entry for gosmore svn path=/nixpkgs/trunk/; revision=22227
2010-06-11 23:37:47 +01:00
gosmore = builderDefsPackage ../applications/misc/gosmore {
inherit fetchsvn curl pkgconfig libxml2;
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 17:26:58 +01:00
gpsbabel = callPackage ../applications/misc/gpsbabel { };
Add `gpscorrelate', a GPS photo correlation tool. svn path=/nixpkgs/trunk/; revision=15814
2009-06-01 23:43:36 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gpscorrelate = callPackage ../applications/misc/gpscorrelate {
Add `gpscorrelate', a GPS photo correlation tool. svn path=/nixpkgs/trunk/; revision=15814
2009-06-01 23:43:36 +01:00
inherit (gtkLibs) gtk;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gpsd = callPackage ../servers/gpsd {
gpsd: Fix client programs. svn path=/nixpkgs/trunk/; revision=15812
2009-06-01 01:03:08 +01:00
# We need a Python with NCurses bindings.
python = pythonFull;
Add `gpsd', a GPS service daemon. svn path=/nixpkgs/trunk/; revision=15809
2009-05-31 12:29:42 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gv = callPackage ../applications/misc/gv { };
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
hello = callPackage ../applications/misc/hello/ex-2 { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
homebank = callPackage ../applications/office/homebank {
Adding homebank, personal finance software. svn path=/nixpkgs/trunk/; revision=19698
2010-01-26 22:22:11 +00:00
inherit (gtkLibs) gtk;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
htmldoc = callPackage ../applications/misc/htmldoc {
Adding htmldoc. I had to update fltk 1.1 for it to build. svn path=/nixpkgs/trunk/; revision=22096
2010-06-01 22:15:40 +01:00
fltk = fltk11;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
hugin = callPackage ../applications/graphics/hugin {
Hugin: Use `stdenv2', for the CMake-related fixes. svn path=/nixpkgs/trunk/; revision=22594
2010-07-14 00:42:33 +01:00
stdenv = stdenv2;
Adding enblend-fuse, libxmi and hugin. Maybe hugin doesn't run well enough still. svn path=/nixpkgs/trunk/; revision=14894
2009-04-05 22:41:38 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
i810switch = callPackage ../os-specific/linux/i810switch { };
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
Add GNU IceCat 3, GNU's free variant of Mozilla Firefox 3. Currently, MPlayerPlugin can't be built with IceCat 3. svn path=/nixpkgs/trunk/; revision=12437
2008-07-28 16:55:11 +01:00
icecat3 = lowPrio (import ../applications/networking/browsers/icecat-3 {
GNU IceCat 3.6.7. svn path=/nixpkgs/trunk/; revision=22732
2010-07-25 15:16:09 +01:00
inherit fetchurl stdenv xz pkgconfig perl zip libjpeg libpng zlib cairo
GNU IceCat 3.6: Disable WiFi stuff for now. svn path=/nixpkgs/trunk/; revision=19744
2010-02-01 09:16:56 +00:00
python dbus dbus_glib freetype fontconfig bzip2 xlibs alsaLib libnotify
wirelesstools;
IceCat: Use GNOME VFS and libgnomeui. svn path=/nixpkgs/trunk/; revision=12441
2008-07-28 21:41:14 +01:00
inherit (gnome) libIDL libgnomeui gnomevfs gtk pango;
GNU IceCat 3.6.7. svn path=/nixpkgs/trunk/; revision=22732
2010-07-25 15:16:09 +01:00
inherit (xlibs) pixman;
GNU IceCat: Add PLY as a build input. svn path=/nixpkgs/trunk/; revision=16429
2009-07-19 13:34:14 +01:00
inherit (pythonPackages) ply;
Add GNU IceCat 3, GNU's free variant of Mozilla Firefox 3. Currently, MPlayerPlugin can't be built with IceCat 3. svn path=/nixpkgs/trunk/; revision=12437
2008-07-28 16:55:11 +01:00
});
GNU IceCat: Allow compilation of XulRunner. In turn, this allows compilation of plug-ins like MPlayer's. svn path=/nixpkgs/trunk/; revision=12930
2008-09-29 22:58:25 +01:00
icecatXulrunner3 = lowPrio (import ../applications/networking/browsers/icecat-3 {
application = "xulrunner";
GNU IceCat 3.6.7. svn path=/nixpkgs/trunk/; revision=22732
2010-07-25 15:16:09 +01:00
inherit fetchurl stdenv xz pkgconfig perl zip libjpeg libpng zlib cairo
GNU IceCat 3.6: Disable WiFi stuff for now. svn path=/nixpkgs/trunk/; revision=19744
2010-02-01 09:16:56 +00:00
python dbus dbus_glib freetype fontconfig bzip2 xlibs alsaLib libnotify
wirelesstools;
GNU IceCat: Allow compilation of XulRunner. In turn, this allows compilation of plug-ins like MPlayer's. svn path=/nixpkgs/trunk/; revision=12930
2008-09-29 22:58:25 +01:00
inherit (gnome) libIDL libgnomeui gnomevfs gtk pango;
GNU IceCat 3.6.7. svn path=/nixpkgs/trunk/; revision=22732
2010-07-25 15:16:09 +01:00
inherit (xlibs) pixman;
Add missing argument to `icecatXulrunner3'. Reported by Peter Simons. svn path=/nixpkgs/trunk/; revision=16432
2009-07-20 15:14:28 +01:00
inherit (pythonPackages) ply;
GNU IceCat: Allow compilation of XulRunner. In turn, this allows compilation of plug-ins like MPlayer's. svn path=/nixpkgs/trunk/; revision=12930
2008-09-29 22:58:25 +01:00
});
icecat3Xul =
Fix derivation name of `icecat3Xul'. svn path=/nixpkgs/trunk/; revision=16357
2009-07-14 16:22:31 +01:00
(symlinkJoin "icecat-with-xulrunner-${icecat3.version}"
[ icecat3 icecatXulrunner3 ])
IceCat: Inherit `isFirefox3Like' in `icecat3Xul'. svn path=/nixpkgs/trunk/; revision=13615
2008-12-12 09:38:31 +00:00
// { inherit (icecat3) gtk isFirefox3Like meta; };
GNU IceCat: Allow compilation of XulRunner. In turn, this allows compilation of plug-ins like MPlayer's. svn path=/nixpkgs/trunk/; revision=12930
2008-09-29 22:58:25 +01:00
icecatWrapper = wrapFirefox icecat3Xul "icecat" "";
Add GNU IceCat 3, GNU's free variant of Mozilla Firefox 3. Currently, MPlayerPlugin can't be built with IceCat 3. svn path=/nixpkgs/trunk/; revision=12437
2008-07-28 16:55:11 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
icewm = callPackage ../applications/window-managers/icewm { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
ikiwiki = callPackage ../applications/misc/ikiwiki {
pkgs/tools/typesetting/asciidoc: updated to version 8.5.1 New asciidoc versions do have a proper configure script. Using that simplifies the build instructions a bit. svn path=/nixpkgs/trunk/; revision=18076
2009-11-03 15:57:22 +00:00
inherit (perlPackages) TextMarkdown URI HTMLParser HTMLScrubber
pkgs/top-level/all-packages.nix: added RPC-XML support to ikiwiki This is required for the 'rst' plugin and for non-perl plugin support in general. svn path=/nixpkgs/trunk/; revision=21421
2010-04-29 10:35:20 +01:00
HTMLTemplate TimeDate CGISession DBFile CGIFormBuilder LocaleGettext
pkgs/applications/misc/ikiwiki: added build input PerlMagick Without ImageMagick support, Ikiwiki cannot handle images. svn path=/nixpkgs/trunk/; revision=21456
2010-04-30 11:49:43 +01:00
RpcXML XMLSimple PerlMagick;
update ikiwiki and fix its dependencies. - when installing perl.XML_LibXML: Cannot write to /nix/store/032pczp65kvry14ln8g8s244qlysrfi1-perl-XML-SAX-0.96/lib/perl5/site_perl/5.10.1/XML/SAX/ParserDetails.ini: Permission denied at /nix/store/032pczp65kvry14ln8g8s244qlysrfi1-perl-XML-SAX-0.96/lib/perl5/site_perl/5.10.1/XML/SAX.pm line 191. SKIP_SAX_INSTALL=1 fixes this. - RPC-XML hangs on during the check phase. A temporary work around is to set doCheck as false. svn path=/nixpkgs/trunk/; revision=22550
2010-07-09 14:16:00 +01:00
gitSupport = getPkgConfig "ikiwiki" "git" false;
monotoneSupport = getPkgConfig "ikiwiki" "monotone" false;
Adding support of external utilities in ikiwiki svn path=/nixpkgs/trunk/; revision=17845
2009-10-16 09:38:25 +01:00
extraUtils = [];
Adding the basics for 'ikiwiki'. I did not try how it serves the pages, but at least "ikiwiki --setup ikiwikipath/etc/auto.setup" works for me with git. svn path=/nixpkgs/trunk/; revision=17808
2009-10-14 22:00:54 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
imagemagick = callPackage ../applications/graphics/ImageMagick {
* More cleanup. svn path=/nixpkgs/trunk/; revision=22795
2010-07-28 16:35:01 +01:00
tetex = null;
librsvg = null;
* ImageMagick: don't need to keep old versions I guess. * texFunctions.simpleTexToPNG: purity (use our own ImageMagick). svn path=/nixpkgs/trunk/; revision=11836
2008-05-16 12:26:23 +01:00
};
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
imagemagickBig = callPackage ../applications/graphics/ImageMagick { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
Add Impressive (formerly known as `KeyJNote'). svn path=/nixpkgs/trunk/; revision=14618
2009-03-19 16:40:28 +00:00
# Impressive, formerly known as "KeyJNote".
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
impressive = callPackage ../applications/office/impressive {
Add Impressive (formerly known as `KeyJNote'). svn path=/nixpkgs/trunk/; revision=14618
2009-03-19 16:40:28 +00:00
# XXX These are the PyOpenGL dependencies, which we need here.
pyopengl: Move to `python-packages.nix'. svn path=/nixpkgs/trunk/; revision=20317
2010-03-01 17:08:25 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
inherit (pythonPackages) pyopengl; };
Add Impressive (formerly known as `KeyJNote'). svn path=/nixpkgs/trunk/; revision=14618
2009-03-19 16:40:28 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
inkscape = callPackage ../applications/graphics/inkscape {
adding python package lxml to make scripts in inkscape work svn path=/nixpkgs/trunk/; revision=17858
2009-10-18 05:43:40 +01:00
inherit (pythonPackages) lxml;
glibmm and gtkmm moved into gtkLibs svn path=/nixpkgs/branches/stdenv-updates/; revision=10478
2008-02-03 13:18:37 +00:00
inherit (gtkLibs) gtk glib glibmm gtkmm;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
ion3 = callPackage ../applications/window-managers/ion-3 {
* Clean up indentation (expanded tabs etc.). svn path=/nixpkgs/trunk/; revision=11150
2008-03-17 09:41:28 +00:00
lua = lua5;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
iptraf = callPackage ../applications/networking/iptraf { };
Adding iptraf 3.0.0 (the last iptraf I found, last updated in 2005) It runs without complains if you "mkdir -p /var/run/iptraf /var/local/iptraf" svn path=/nixpkgs/trunk/; revision=17752
2009-10-12 11:52:47 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
irssi = callPackage ../applications/networking/irc/irssi { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jackmeter = callPackage ../applications/audio/jackmeter { };
adding jackmeter svn path=/nixpkgs/trunk/; revision=17324
2009-09-21 10:58:33 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jedit = callPackage ../applications/editors/jedit { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
jigdo = callPackage ../applications/misc/jigdo {
adding jigdo-lite svn path=/nixpkgs/trunk/; revision=17020
2009-09-10 17:57:31 +01:00
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 17:26:58 +01:00
joe = callPackage ../applications/editors/joe { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
jwm = callPackage ../applications/window-managers/jwm { };
added jwm expression provided by tachermourir (mailinglist) svn path=/nixpkgs/trunk/; revision=11281
2008-03-25 09:50:54 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
kermit = callPackage ../tools/misc/kermit { };
Adding kermit. svn path=/nixpkgs/trunk/; revision=17114
2009-09-14 19:50:17 +01:00
kino (compiling but neither finding libX11 nor libghtread) and libiec61883 (dependency) added svn path=/nixpkgs/trunk/; revision=10133
2008-01-13 15:21:21 +00:00
kino = import ../applications/video/kino {
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
inherit fetchurl stdenv pkgconfig libxml2 perl perlXMLParser
kino not finding dll fix. Now you can start it svn path=/nixpkgs/trunk/; revision=10138
2008-01-13 18:08:51 +00:00
libdv libraw1394 libavc1394 libiec61883 x11 gettext cairo; /* libavformat */
kino (compiling but neither finding libX11 nor libghtread) and libiec61883 (dependency) added svn path=/nixpkgs/trunk/; revision=10133
2008-01-13 15:21:21 +00:00
inherit libsamplerate ffmpeg;
kino not finding dll fix. Now you can start it svn path=/nixpkgs/trunk/; revision=10138
2008-01-13 18:08:51 +00:00
inherit (gnome) libglade gtk glib;
kino (compiling but neither finding libX11 nor libghtread) and libiec61883 (dependency) added svn path=/nixpkgs/trunk/; revision=10133
2008-01-13 15:21:21 +00:00
inherit (xlibs) libXv libX11;
kino not finding dll fix. Now you can start it svn path=/nixpkgs/trunk/; revision=10138
2008-01-13 18:08:51 +00:00
inherit (gtkLibs) pango;
* Merged most of the stdenv-updates branch. Some stuff didn't merge cleanly right away (kde-4, kernel stuff) so it should be merged later. But the stdenv stuff is all there. svn path=/nixpkgs/branches/stdenv-updates-merge/; revision=10793
2008-02-20 23:02:41 +00:00
# # optional
# inherit ffmpeg2theora sox, vorbis-tools lame mjpegtools dvdauthor 'Q'dvdauthor growisofs mencoder;
kino (compiling but neither finding libX11 nor libghtread) and libiec61883 (dependency) added svn path=/nixpkgs/trunk/; revision=10133
2008-01-13 15:21:21 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lame = callPackage ../applications/audio/lame { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
larswm = callPackage ../applications/window-managers/larswm { };
Fixing glibcInfo - it did not build. svn path=/nixpkgs/trunk/; revision=21755
2010-05-12 20:31:18 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ladspaH = callPackage ../applications/audio/ladspa-plugins/ladspah.nix { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
ladspaPlugins = callPackage ../applications/audio/ladspa-plugins {
Fix FFTW argument to Ladspa Plugins svn path=/nixpkgs/trunk/; revision=22414
2010-06-25 19:21:19 +01:00
fftw = fftwSinglePrec;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
ldcpp = callPackage ../applications/networking/p2p/ldcpp {
Added LinuxDC++. Claimed to support newer protocol - claim is by valknut team.. svn path=/nixpkgs/trunk/; revision=11132
2008-03-15 06:11:45 +00:00
inherit (gtkLibs) gtk;
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 17:26:58 +01:00
links = callPackage ../applications/networking/browsers/links { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ledger = callPackage ../applications/office/ledger { };
Add package ledger svn path=/nixpkgs/trunk/; revision=18316
2009-11-10 11:02:45 +00:00
Adding Links2 svn path=/nixpkgs/trunk/; revision=17949
2009-10-24 16:39:54 +01:00
links2 = (builderDefsPackage ../applications/networking/browsers/links2) {
Fix wxGTK reference for xchm svn path=/nixpkgs/trunk/; revision=18156
2009-11-05 21:08:53 +00:00
inherit fetchurl stdenv bzip2 zlib libjpeg libpng libtiff
Adding Links2 svn path=/nixpkgs/trunk/; revision=17949
2009-10-24 16:39:54 +01:00
gpm openssl SDL SDL_image SDL_net pkgconfig;
inherit (xlibs) libX11 libXau xproto 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 17:26:58 +01:00
lynx = callPackage ../applications/networking/browsers/lynx { };
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
lyx = callPackage ../applications/misc/lyx {
lyx added svn path=/nixpkgs/trunk/; revision=10416
2008-01-30 19:38:07 +00:00
qt = qt4;
};
Adding the matchbox window manager svn path=/nixpkgs/trunk/; revision=23076
2010-08-09 23:40:51 +01:00
matchbox = callPackage ../applications/window-managers/matchbox { };
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
meld = callPackage ../applications/version-management/meld {
Adding 'meld' svn path=/nixpkgs/trunk/; revision=20963
2010-04-06 20:39:29 +01:00
inherit (gnome) scrollkeeper;
pygtk = pyGtkGlade;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
mercurial = callPackage ../applications/version-management/mercurial {
mercurial : hgk = hg view = gitk for hg tool support svn path=/nixpkgs/trunk/; revision=13093
2008-10-18 13:01:24 +01:00
guiSupport = getConfig ["mercurial" "guiSupport"] false; # for hgk (gitk gui for hg)
* Add https support for mercurial. svn path=/nixpkgs/trunk/; revision=18345
2009-11-14 20:14:09 +00:00
python = # allow cloning sources from https servers.
if getConfig ["mercurial" "httpsSupport"] true
then pythonFull
else pythonBase;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
merkaartor = callPackage ../applications/misc/merkaartor {
Adding merkaartor (a qt-based openstreetmap editor) svn path=/nixpkgs/trunk/; revision=22244
2010-06-13 20:32:04 +01:00
qt = qt4;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
meshlab = callPackage ../applications/graphics/meshlab {
Adding muparser and meshlab. svn path=/nixpkgs/trunk/; revision=15585
2009-05-13 11:21:29 +01:00
qt = qt4;
};
Added Midori - a light, WebKit-based GTK browser. svn path=/nixpkgs/trunk/; revision=12818
2008-09-07 13:58:56 +01:00
midori = builderDefsPackage (import ../applications/networking/browsers/midori) {
maudeUnstable: updated full-maude to latest alpha release svn path=/nixpkgs/trunk/; revision=13017
2008-10-09 11:10:49 +01:00
inherit imagemagick intltool python pkgconfig webkit libxml2
Update WebKit and Midori svn path=/nixpkgs/trunk/; revision=15849
2009-06-04 12:20:26 +01:00
which gettext makeWrapper file libidn sqlite docutils libnotify;
* Make GTK 2.18 the default, and get rid of the deep overrides. (BTW, there seems to be a much cleaner solution than deepOverride, namely call all-packages.nix with an appropriate packageOverrides set.) svn path=/nixpkgs/branches/xorg-7.5/; revision=18025
2009-10-29 14:19:13 +00:00
inherit (gtkLibs) gtk glib;
Make midori use the webkit version from libsoup svn path=/nixpkgs/trunk/; revision=22544
2010-07-09 12:35:07 +01:00
inherit (gnome28) gtksourceview;
inherit (webkit.passthru.args) libsoup;
Added Midori - a light, WebKit-based GTK browser. svn path=/nixpkgs/trunk/; revision=12818
2008-09-07 13:58:56 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
minicom = callPackage ../tools/misc/minicom { };
all-packages.nix changes for all the previous commits svn path=/nixpkgs/trunk/; revision=11564
2008-04-11 10:32:27 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mmex = callPackage ../applications/office/mmex { };
Adding some kind of build expression for money manager ex. It expects to find its resource files in '.', and it also wants to write at '.'. I think this has to be fixed upstream. svn path=/nixpkgs/trunk/; revision=19655
2010-01-25 21:40:52 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
monodevelop = callPackage ../applications/editors/monodevelop {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gnome) gnomevfs libbonobo libglade libgnome GConf glib gtk;
mozilla = firefox;
gtksharp = gtksharp2;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
monodoc = callPackage ../applications/editors/monodoc {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
gtksharp = gtksharp1;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
monotone = callPackage ../applications/version-management/monotone {
Moved monotone packages to a more appropriate position within all-packages.nix svn path=/nixpkgs/trunk/; revision=19144
2009-12-29 11:57:27 +00:00
lua = lua5;
};
monotoneViz = builderDefsPackage (import ../applications/version-management/monotone-viz/mtn-head.nix) {
inherit ocaml lablgtk graphviz pkgconfig autoconf automake libtool;
inherit (gnome) gtk libgnomecanvas glib;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
mozilla = callPackage ../applications/networking/browsers/mozilla {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
inherit (gtkLibs) gtk;
inherit (gnome) libIDL;
};
Added mozplugger - an universal launching plugin for Mozilla programs svn path=/nixpkgs/trunk/; revision=14009
2009-02-08 17:23:22 +00:00
mozplugger = builderDefsPackage (import ../applications/networking/browsers/mozilla-plugins/mozplugger) {
Bumped boost libraries to version 1.38.0. svn path=/nixpkgs/trunk/; revision=14031
2009-02-11 10:02:10 +00:00
inherit firefox;
Added mozplugger - an universal launching plugin for Mozilla programs svn path=/nixpkgs/trunk/; revision=14009
2009-02-08 17:23:22 +00:00
inherit (xlibs) libX11 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 17:26:58 +01:00
mpc123 = callPackage ../applications/audio/mpc123 { };
Add mpc123, a Musepack command-line player. svn path=/nixpkgs/trunk/; revision=19722
2010-01-28 22:34:27 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mpg321 = callPackage ../applications/audio/mpg321 { };
Add mpg321, libao and libid3tag; upgrade libmad. svn path=/nixpkgs/trunk/; revision=10626
2008-02-11 21:02:38 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
MPlayer = callPackage ../applications/video/MPlayer {
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
alsaSupport = true;
alsa = alsaLib;
theoraSupport = true;
cacaSupport = true;
xineramaSupport = true;
randrSupport = true;
Added CDDA support to MPlayer svn path=/nixpkgs/trunk/; revision=10978
2008-03-06 09:34:36 +00:00
cddaSupport = true;
Adding amr support in mplayer. That should be enabled by the user, because those libraries are not redistributable. I don't know if the 'unfree' in the amr libraries will stop mplayer being built without its support. We would have to write the all-packages MPlayer expression different, in this case. svn path=/nixpkgs/trunk/; revision=17635
2009-10-04 22:31:34 +01:00
amrSupport = getConfig [ "MPlayer" "amr" ] false;
Updating x264, and adding x264 support to mplayer and ffmpeg. svn path=/nixpkgs/trunk/; revision=21451
2010-04-30 09:33:47 +01:00
x264Support = true;
Adding xvid, to ffmpeg and mplayer. svn path=/nixpkgs/trunk/; revision=21469
2010-04-30 22:47:09 +01:00
xvidSupport = true;
* Fix indentation mess-up in r9931. svn path=/nixpkgs/trunk/; revision=9973
2007-12-30 22:02:04 +00:00
};
* Build Firefox 3 on top of xulrunner. This significantly reduces the build time and makes Firefox itself only 3 megabytes or so large. * Fixed building the mplayerplug-in on Firefox 3. Since the latter now uses xulrunner, we no longer need the firefox3Xul hack. TODO: do this for Icecat as well. svn path=/nixpkgs/trunk/; revision=13160
2008-10-30 13:00:50 +00:00
MPlayerPlugin = browser:
Add GNU IceCat 3, GNU's free variant of Mozilla Firefox 3. Currently, MPlayerPlugin can't be built with IceCat 3. svn path=/nixpkgs/trunk/; revision=12437
2008-07-28 16:55:11 +01:00
import ../applications/networking/browsers/mozilla-plugins/mplayerplug-in {
* Build Firefox 3 on top of xulrunner. This significantly reduces the build time and makes Firefox itself only 3 megabytes or so large. * Fixed building the mplayerplug-in on Firefox 3. Since the latter now uses xulrunner, we no longer need the firefox3Xul hack. TODO: do this for Icecat as well. svn path=/nixpkgs/trunk/; revision=13160
2008-10-30 13:00:50 +00:00
inherit browser;
Add GNU IceCat 3, GNU's free variant of Mozilla Firefox 3. Currently, MPlayerPlugin can't be built with IceCat 3. svn path=/nixpkgs/trunk/; revision=12437
2008-07-28 16:55:11 +01:00
inherit fetchurl stdenv pkgconfig gettext;
inherit (xlibs) libXpm;
# !!! should depend on MPlayer
};
* Browser plugin for MPlayer. svn path=/nixpkgs/trunk/; revision=498
2003-11-13 13:11:38 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mrxvt = callPackage ../applications/misc/mrxvt { };
mrxvt terminal emulator supporting bg images added svn path=/nixpkgs/trunk/; revision=9255
2007-09-04 21:06:18 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
multisync = callPackage ../applications/misc/multisync {
added multisync - plugins are not yet shown ? svn path=/nixpkgs/trunk/; revision=13539
2008-12-02 12:25:56 +00:00
inherit (gnome) gtk glib ORBit2 libbonobo libgnomeui 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 17:26:58 +01:00
mutt = callPackage ../applications/networking/mailreaders/mutt { };
* mutt was incorrectly listed under tools, not applications svn path=/nixpkgs/trunk/; revision=9058
2007-08-06 16:09:38 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
msmtp = callPackage ../applications/networking/msmtp { };
added: dnsmasq, uisp, fltk libixp_for_wmii, acerhk kernel module, reiserfsprogs, radeontools, msmtp, procmail, pstree, gxemul changed: umlutilities to also support building tunctl optionally (needing kernel header files) wmii updated and wmiimenu added svn path=/nixpkgs/trunk/; revision=9242
2007-09-03 13:10:57 +01:00
Adding 'mupdf', a lightweight PDF 1.7 viewer As a side effect, I add openjpeg and jbig2dec. svn path=/nixpkgs/trunk/; revision=23069
2010-08-09 21:59:38 +01:00
mupdf = callPackage ../applications/misc/mupdf {
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
mythtv = callPackage ../applications/video/mythtv {
* MythTV 0.21. svn path=/nixpkgs/trunk/; revision=12177
2008-06-23 10:01:04 +01:00
qt3 = qt3mysql;
* Added Xine. svn path=/nixpkgs/trunk/; revision=1850
2004-12-10 23:16:23 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
nano = callPackage ../applications/editors/nano { };
add xawtv here svn path=/nixpkgs/trunk/; revision=4579
2006-01-20 11:30:24 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
nedit = callPackage ../applications/editors/nedit {
Attempt to mark up packages with platform assertions svn path=/nixpkgs/trunk/; revision=16850
2009-08-25 07:36:05 +01: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 17:26:58 +01:00
};
* Added `zapping', a TV viewer application. It depends on Gnome, so lots of packages are needed. svn path=/nixpkgs/trunk/; revision=681
2004-01-21 09:34:19 +00:00
adding netsurf browser. No JavaScript yet svn path=/nixpkgs/trunk/; revision=17077
2009-09-13 09:54:47 +01:00
netsurfBrowser = netsurf.browser;
finally fixing netsurf svn path=/nixpkgs/trunk/; revision=17328
2009-09-21 11:09:20 +01:00
netsurf = recurseIntoAttrs (import ../applications/networking/browsers/netsurf { inherit pkgs; });
adding netsurf browser. No JavaScript yet svn path=/nixpkgs/trunk/; revision=17077
2009-09-13 09:54:47 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
nvi = callPackage ../applications/editors/nvi { };
Adding nvi, another small vi clone. svn path=/nixpkgs/trunk/; revision=15099
2009-04-16 20:28:57 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
openjump = callPackage ../applications/misc/openjump { };
adding GIS application OpenJUMP svn path=/nixpkgs/trunk/; revision=21735
2010-05-11 23:19:37 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
openoffice = callPackage ../applications/office/openoffice {
* Factor groups of strongly related packages out of `all-packages-generic.nix'. svn path=/nixpkgs/trunk/; revision=913
2004-04-05 14:34:13 +01:00
inherit (gtkLibs) gtk;
* Drop the "perl" prefix from Perl attribute names. It's redundant now that Perl packages are in their own namespace (perlPackages.<pkg>). svn path=/nixpkgs/trunk/; revision=15176
2009-04-20 13:49:35 +01:00
inherit (perlPackages) ArchiveZip CompressZlib;
Try removing gnome26 references svn path=/nixpkgs/branches/xorg-7.5/; revision=18086
2009-11-04 00:39:27 +00:00
inherit (gnome) GConf ORBit2;
* Try to build OpenOffice and Go-oo with Neon 0.29, since 0.26 doesn't work anymore. svn path=/nixpkgs/branches/x-updates/; revision=22702
2010-07-22 11:41:34 +01:00
neon = neon029;
OpenOffice.org update attempt to 3.2.0 - maybe it will work I'll wait for the hydra report. svn path=/nixpkgs/trunk/; revision=21850
2010-05-18 21:57:00 +01:00
stdenv = stdenv2;
* Added gqview. svn path=/nixpkgs/trunk/; revision=497
2003-11-11 16:13:13 +00:00
};
Removed duplicate stdenv in OO.org svn path=/nixpkgs/trunk/; revision=9002
2007-07-19 11:32:09 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
go_oo = callPackage ../applications/office/openoffice/go-oo.nix {
Adding go-oo in multiple languages. The expression and names can be improved, but at least I reached a point where it works. Patches welcome - even without asking. I should add a way to regenerate src.nix automatically too, but the information on what to dowload is only inside their download script generated after configure. There are more things that can be added: kde4 support, gstreamer, ... I did not check that all the buildInputs are needed - most come from the old openoffice expression. svn path=/nixpkgs/trunk/; revision=21969
2010-05-25 18:05:52 +01:00
inherit (gtkLibs) gtk;
inherit (perlPackages) ArchiveZip CompressZlib;
inherit (gnome) GConf ORBit2;
* Try to build OpenOffice and Go-oo with Neon 0.29, since 0.26 doesn't work anymore. svn path=/nixpkgs/branches/x-updates/; revision=22702
2010-07-22 11:41:34 +01:00
neon = neon029;
Adding go-oo in multiple languages. The expression and names can be improved, but at least I reached a point where it works. Patches welcome - even without asking. I should add a way to regenerate src.nix automatically too, but the information on what to dowload is only inside their download script generated after configure. There are more things that can be added: kde4 support, gstreamer, ... I did not check that all the buildInputs are needed - most come from the old openoffice expression. svn path=/nixpkgs/trunk/; revision=21969
2010-05-25 18:05:52 +01:00
stdenv = stdenv2;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
opera = callPackage ../applications/networking/browsers/opera {
* Some cleanup of the Opera expression. It doesn't need the libstdcpp from GCC 3.3 anymore, GCC 4.x is fine. So we can use the regular Qt 3 build. Also, there don't seem to be any references to Motif anymore. svn path=/nixpkgs/trunk/; revision=16932
2009-09-02 14:24:08 +01:00
qt = qt3;
Tried to add kuickshow (a pretty fast image viewer that used to be distributed by default in KDE). Unfortunately it doesn't work, because of some strange problems with mime types. But well, it compiles. The libraries are useful anyway: - arts (kde) - imlib (gnome) - libungif (aka libgif) svn path=/nixpkgs/trunk/; revision=6111
2006-08-13 10:46:54 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
pan = callPackage ../applications/networking/newsreaders/pan {
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
inherit (gtkLibs) gtk;
* Revive gmime-2.2.x, because gmime-2.4.x is not backwards compatible. For instance, Pan requires gmime-2.2. svn path=/nixpkgs/trunk/; revision=22543
2010-07-09 10:12:42 +01:00
gmime = gmime_2_2;
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
spellChecking = false;
Added libraries: - gtkmm: C++ bindings for gtk - glibmm: C++ bindings for glib - libsigc++ (C++) Added applications: - Batik: SVG rasterizer (and more) - Inkscape: vector graphics drawing application Upgraded: - boehm-gc svn path=/nixpkgs/trunk/; revision=3792
2005-09-07 15:57:30 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
panotools = callPackage ../applications/graphics/panotools { };
all-packages.nix: commented out package 'vice' error: getting status of `/usr/local/src/nix-pkgs-current/pkgs/misc/emulators/vice': No such file or directory svn path=/nixpkgs/trunk/; revision=15646
2009-05-18 14:53:01 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
pavucontrol = callPackage ../applications/audio/pavucontrol {
Add Pavucontrol (untested). svn path=/nixpkgs/branches/stdenv-updates/; revision=14864
2009-04-03 16:58:18 +01:00
inherit (gtkLibs) gtkmm;
inherit (gnome) libglademm;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
paraview = callPackage ../applications/graphics/paraview {
Trying to fix the nixpkgs-tarball, after I broke it again due to assuming 'gcc' to be pure as that of stdenvLinux. svn path=/nixpkgs/trunk/; revision=20671
2010-03-16 21:53:48 +00:00
stdenv = stdenv2;
Adding paraview. svn path=/nixpkgs/trunk/; revision=14794
2009-03-30 21:06:31 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
partitionManager = callPackage ../tools/misc/partition-manager {
Changed KDE 4.4.x to the default KDE version. Changed qt-4.6.x to the default qt4 version (except for the KDE 4.3.x attribute and older PyQt releases svn path=/nixpkgs/trunk/; revision=20404
2010-03-05 12:00:37 +00:00
kde = kde44;
Adding partition manager. It builds. But it waits forever on some devices? So maybe just use gparted.. svn path=/nixpkgs/trunk/; revision=17021
2009-09-10 17:57:34 +01:00
qt = qt4;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pdftk = callPackage ../tools/typesetting/pdftk { };
Adding pdftk for roconnor. svn path=/nixpkgs/trunk/; revision=22097
2010-06-02 09:21:49 +01:00
moved pidgin near packages starting with p (was near f maybe because pidgin was called gaim?) svn path=/nixpkgs/trunk/; revision=11724
2008-04-26 00:40:18 +01:00
pidgin = import ../applications/networking/instant-messengers/pidgin {
update to 2.6.5, also add python dependency for extensions and all that svn path=/nixpkgs/trunk/; revision=19352
2010-01-11 13:25:05 +00:00
inherit fetchurl stdenv pkgconfig perl perlXMLParser libxml2 nss nspr farsight2 python
update to 2.6.4. voice and video are not working atm svn path=/nixpkgs/trunk/; revision=19086
2009-12-23 21:05:29 +00:00
gtkspell aspell gettext ncurses avahi dbus dbus_glib lib intltool libidn;
Options to remove OpenSSL and use gnuTLS for Pidgin (reported to work better with, say, Amessage or any other XMPP server which requires strong channel encryption) svn path=/nixpkgs/trunk/; revision=12813
2008-09-06 11:30:55 +01:00
openssl = if (getConfig ["pidgin" "openssl"] true) then openssl else null;
gnutls = if (getConfig ["pidgin" "gnutls"] false) then gnutls else null;
moved pidgin near packages starting with p (was near f maybe because pidgin was called gaim?) svn path=/nixpkgs/trunk/; revision=11724
2008-04-26 00:40:18 +01:00
GStreamer = gst_all.gstreamer;
inherit (gtkLibs) gtk;
inherit (gnome) startupnotification;
inherit (xlibs) libXScrnSaver;
add voice and video svn path=/nixpkgs/trunk/; revision=19136
2009-12-27 16:49:08 +00:00
inherit (gst_all) gstPluginsBase;
moved pidgin near packages starting with p (was near f maybe because pidgin was called gaim?) svn path=/nixpkgs/trunk/; revision=11724
2008-04-26 00:40:18 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
pidginlatex = callPackage ../applications/networking/instant-messengers/pidgin-plugins/pidgin-latex {
moved pidgin near packages starting with p (was near f maybe because pidgin was called gaim?) svn path=/nixpkgs/trunk/; revision=11724
2008-04-26 00:40:18 +01:00
imagemagick = imagemagickBig;
inherit (gtkLibs) glib gtk;
};
Fixed Python StringTemplate library. Most importantly, this change required updating the ANTLR 2.x expression to install the Python run-time library. While we're at it, we're building the run-time library for C++ and Java, too. There is still work to be done: the stringtemplate library doesn't find antlr.py without help yet. svn path=/nixpkgs/trunk/; revision=14489
2009-03-10 12:01:22 +00:00
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
pidginlatexSF = builderDefsPackage
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
(import ../applications/networking/instant-messengers/pidgin-plugins/pidgin-latex/pidgin-latex-sf.nix)
moved pidgin near packages starting with p (was near f maybe because pidgin was called gaim?) svn path=/nixpkgs/trunk/; revision=11724
2008-04-26 00:40:18 +01:00
{
inherit pkgconfig pidgin texLive imagemagick which;
inherit (gtkLibs) glib gtk;
};
msn-pecan: an alternative MSN plugin for pidgin svn path=/nixpkgs/trunk/; revision=23050
2010-08-09 07:51:34 +01: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 17:26:58 +01:00
pidginotr = callPackage ../applications/networking/instant-messengers/pidgin-plugins/otr { };
moved pidgin near packages starting with p (was near f maybe because pidgin was called gaim?) svn path=/nixpkgs/trunk/; revision=11724
2008-04-26 00:40:18 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pidginsipe = callPackage ../applications/networking/instant-messengers/pidgin-plugins/sipe { };
pidgin plugin sipe contributed by David Brown svn path=/nixpkgs/trunk/; revision=21730
2010-05-11 18:28:54 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pinfo = callPackage ../applications/misc/pinfo { };
Added libraries: - gtkmm: C++ bindings for gtk - glibmm: C++ bindings for glib - libsigc++ (C++) Added applications: - Batik: SVG rasterizer (and more) - Inkscape: vector graphics drawing application Upgraded: - boehm-gc svn path=/nixpkgs/trunk/; revision=3792
2005-09-07 15:57:30 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
pinta = callPackage ../applications/graphics/pinta {
Attempt at adding 'pinta'. It still does not build due to mono problems. Nevertheless, I updated the gnome attribute names a bit so all that gtk-sharp-2 goes a bit beyond. svn path=/nixpkgs/trunk/; revision=22287
2010-06-15 23:25:38 +01:00
gtksharp = gtksharp2;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
pqiv = callPackage ../applications/graphics/pqiv {
* added pqiv image viewer svn path=/nixpkgs/trunk/; revision=11908
2008-05-27 16:05:16 +01:00
inherit (gtkLibs) gtk;
};
added: dnsmasq, uisp, fltk libixp_for_wmii, acerhk kernel module, reiserfsprogs, radeontools, msmtp, procmail, pstree, gxemul changed: umlutilities to also support building tunctl optionally (needing kernel header files) wmii updated and wmiimenu added svn path=/nixpkgs/trunk/; revision=9242
2007-09-03 13:10:57 +01: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 17:26:58 +01:00
procmail = callPackage ../applications/misc/procmail { };
added: dnsmasq, uisp, fltk libixp_for_wmii, acerhk kernel module, reiserfsprogs, radeontools, msmtp, procmail, pstree, gxemul changed: umlutilities to also support building tunctl optionally (needing kernel header files) wmii updated and wmiimenu added svn path=/nixpkgs/trunk/; revision=9242
2007-09-03 13:10:57 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pstree = callPackage ../applications/misc/pstree { };
added: dnsmasq, uisp, fltk libixp_for_wmii, acerhk kernel module, reiserfsprogs, radeontools, msmtp, procmail, pstree, gxemul changed: umlutilities to also support building tunctl optionally (needing kernel header files) wmii updated and wmiimenu added svn path=/nixpkgs/trunk/; revision=9242
2007-09-03 13:10:57 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pythonmagick = callPackage ../applications/graphics/PythonMagick { };
add PythonMagic svn path=/nixpkgs/trunk/; revision=9086
2007-08-09 20:58:39 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
qemu = callPackage ../applications/virtualization/qemu/0.12.3.nix { };
Fixed bridge-utils, added qemu, tuned builder-defs unpack, added xlaunch - a tool to launch X using everything possible from the job except slim. svn path=/nixpkgs/trunk/; revision=9985
2007-12-31 08:49:41 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
qemuSVN = callPackage ../applications/virtualization/qemu/svn-6642.nix { };
Qemu SVN head.. svn path=/nixpkgs/trunk/; revision=14222
2009-02-24 12:22:15 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
qemuImage = callPackage ../applications/virtualization/qemu/linux-img { };
Fixed bridge-utils, added qemu, tuned builder-defs unpack, added xlaunch - a tool to launch X using everything possible from the job except slim. svn path=/nixpkgs/trunk/; revision=9985
2007-12-31 08:49:41 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
qtpfsgui = callPackage ../applications/graphics/qtpfsgui { };
Adding qtpfsgui and pfstools. Updating fftw because the src URL didn't work anymore. svn path=/nixpkgs/trunk/; revision=14892
2009-04-05 22:41:13 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
rapidsvn = callPackage ../applications/version-management/rapidsvn { };
Adding rapidsvn svn path=/nixpkgs/trunk/; revision=20538
2010-03-10 20:44:40 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ratpoison = callPackage ../applications/window-managers/ratpoison { };
Added ratpoison; commented out ext3cow - there is no working version for 2.6.22.1 svn path=/nixpkgs/trunk/; revision=9040
2007-08-03 23:38:36 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
rawtherapee = callPackage ../applications/graphics/rawtherapee {
Adding rawtherapee svn r25 svn path=/nixpkgs/trunk/; revision=19500
2010-01-17 17:49:35 +00: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 17:26:58 +01:00
rcs = callPackage ../applications/version-management/rcs { };
* Added libexif and the exif frontend utility. svn path=/nixpkgs/trunk/; revision=2376
2005-03-11 10:46:20 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
rdesktop = callPackage ../applications/networking/remote/rdesktop { };
* added rdesktop svn path=/nixpkgs/trunk/; revision=10304
2008-01-28 12:28:23 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
RealPlayer = callPackage ../applications/video/RealPlayer {
Hopefully that should a) work b) not break things when it does not work svn path=/nixpkgs/trunk/; revision=16846
2009-08-25 07:04:13 +01: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 17:26:58 +01:00
};
gimp+php in all-packages svn path=/nixpkgs/trunk/; revision=3808
2005-09-11 23:39:06 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
rekonq = callPackage ../applications/networking/browsers/rekonq {
Upgrade rekonq svn path=/nixpkgs/trunk/; revision=22835
2010-07-31 14:06:10 +01:00
inherit (gtkLibs) gtk;
Add rekonq browser (both 0.4.0 and latest git) svn path=/nixpkgs/trunk/; revision=21779
2010-05-15 10:47:32 +01:00
inherit (kde4) qt4 kdelibs automoc4 phonon;
};
* Fix breakage in r22897. svn path=/nixpkgs/trunk/; revision=22901
2010-08-02 18:59:19 +01:00
rsibreak = callPackage ../applications/misc/rsibreak {
Add rsibreak svn path=/nixpkgs/trunk/; revision=22897
2010-08-02 18:19:44 +01:00
inherit (kde4) kdelibs kdebase_workspace;
};
* Fix breakage in r22897. svn path=/nixpkgs/trunk/; revision=22901
2010-08-02 18:59:19 +01:00
rsync = callPackage ../applications/networking/sync/rsync {
pkgs/top-level/all-packages.nix: don't enable ACL support in rsync when building on Solaris svn path=/nixpkgs/trunk/; revision=22999
2010-08-06 13:46:18 +01:00
enableACLs = !(stdenv.isDarwin || stdenv.isSunOS);
add cdrtools. There are some references to some package in /opt/schily, which I haven't checked out completely yet... svn path=/nixpkgs/trunk/; revision=3755
2005-08-30 20:41:10 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
rxvt = callPackage ../applications/misc/rxvt { };
sbagen (binaural sound generator) added svn path=/nixpkgs/trunk/; revision=9317
2007-09-12 11:56:56 +01:00
rxvt-unicode and jdk update provided by Tobias Hammerschmidt svn path=/nixpkgs/trunk/; revision=9561
2007-10-31 12:17:14 +00:00
# = urxvt
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
rxvt_unicode = callPackage ../applications/misc/rxvt_unicode {
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
perlSupport = false; };
rxvt-unicode and jdk update provided by Tobias Hammerschmidt svn path=/nixpkgs/trunk/; revision=9561
2007-10-31 12:17:14 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
sakura = callPackage ../applications/misc/sakura {
applications/misc/sakura: New nixpkg. svn path=/nixpkgs/trunk/; revision=20152
2010-02-21 11:36:49 +00:00
inherit (gtkLibs) gtk;
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 17:26:58 +01:00
sbagen = callPackage ../applications/misc/sbagen { };
sbagen (binaural sound generator) added svn path=/nixpkgs/trunk/; revision=9317
2007-09-12 11:56:56 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
scribus = callPackage ../applications/office/scribus {
adding scribus - don't miss the comment about fonts! svn path=/nixpkgs/trunk/; revision=17866
2009-10-18 05:44:01 +01:00
inherit (gnome) libart_lgpl;
qt = qt3;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
seeks = callPackage ../tools/networking/p2p/seeks { };
Add Seeks, a "social" search engine. svn path=/nixpkgs/trunk/; revision=22698
2010-07-22 10:03:35 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
seg3d = callPackage ../applications/graphics/seg3d {
Getting a better seg3d build. Now it runs from TMPDIR at least. The installation still fails. svn path=/nixpkgs/trunk/; revision=20382
2010-03-04 14:44:43 +00:00
wxGTK = wxGTK28.override {
unicode = 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 17:26:58 +01:00
};
Adding the itk libraries. Adding a skeleton of the seg3d package. It builds, but libraries and rpaths are wrong. I hope to fix it soon. svn path=/nixpkgs/trunk/; revision=20320
2010-03-01 23:31:35 +00:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
semnotes = callPackage ../applications/misc/semnotes {
Addded SemNotes note-taking app svn path=/nixpkgs/trunk/; revision=22340
2010-06-20 13:54:42 +01:00
inherit (kde4) qt4 kdelibs automoc4 phonon soprano;
};
* Use callPackage_i686 for i686-only packages. svn path=/nixpkgs/trunk/; revision=23113
2010-08-11 14:25:30 +01:00
skype_linux = callPackage_i686 ../applications/networking/skype { };
rxvt added svn path=/nixpkgs/trunk/; revision=9256
2007-09-05 09:25:23 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
slim = callPackage ../applications/display-managers/slim { };
* SLiM, a lightweight display manager. svn path=/nixpkgs/trunk/; revision=8044
2007-02-25 22:25:25 +00:00
* Improved a bunch of "name" attributes (mostly missing version numbers). svn path=/nixpkgs/trunk/; revision=17991
2009-10-28 14:06:56 +00:00
sndBase = builderDefsPackage (import ../applications/audio/snd) {
Changed builderDefs to use composedArgsAndFun, reduced number of nulls, made overrides in builderDefsPackage to work in an intuitive manner. svn path=/nixpkgs/trunk/; revision=12655
2008-08-19 06:54:09 +01:00
inherit fetchurl stdenv stringsWithDeps lib fftw;
* Clean up indentation (expanded tabs etc.). svn path=/nixpkgs/trunk/; revision=11150
2008-03-17 09:41:28 +00:00
inherit pkgconfig gmp gettext;
Fixed Snd build svn path=/nixpkgs/trunk/; revision=12124
2008-06-16 17:33:11 +01:00
inherit (xlibs) libXpm libX11;
* Clean up indentation (expanded tabs etc.). svn path=/nixpkgs/trunk/; revision=11150
2008-03-17 09:41:28 +00:00
inherit (gtkLibs) gtk glib;
Added Snd sound editor svn path=/nixpkgs/trunk/; revision=9573
2007-11-03 04:15:13 +00:00
};
meta.function -> passthru.function, not killing other contents of passthru svn path=/nixpkgs/trunk/; revision=13190
2008-11-04 21:24:10 +00:00
snd = sndBase.passthru.function {
snd shows it's help in firefox now svn path=/nixpkgs/trunk/; revision=12651
2008-08-18 17:03:38 +01:00
inherit guile mesa libtool jackaudio alsaLib;
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
Added Snd sound editor svn path=/nixpkgs/trunk/; revision=9573
2007-11-03 04:15:13 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
sonicVisualizer = callPackage ../applications/audio/sonic-visualizer {
adding sonic visualizer (music analysis app) svn path=/nixpkgs/trunk/; revision=17325
2009-09-21 10:58:36 +01:00
inherit (vamp) vampSDK;
qt = qt4;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
sox = callPackage ../applications/misc/audio/sox { };
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
Added StumpWM svn path=/nixpkgs/trunk/; revision=12566
2008-08-09 21:21:33 +01:00
stumpwm = builderDefsPackage (import ../applications/window-managers/stumpwm) {
Updating CLisp and adding SBCL. SBCL currently has to be symlinked to a writable directory (I am investigating a fix). CLisp 2.47 is somewhat incompatible with lots of software, so I added 2.44.1 as preserved version svn path=/nixpkgs/trunk/; revision=15806
2009-05-31 07:07:25 +01:00
inherit texinfo;
clisp = clisp_2_44_1;
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
Added StumpWM svn path=/nixpkgs/trunk/; revision=12566
2008-08-09 21:21:33 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
subversion = callPackage ../applications/version-management/subversion/default.nix {
Add neon-0.29.x, make it default Also stop using "default" neon in all-packages.nix. Minor versions are not source-compatible, so a package should state needed version explicitly. svn path=/nixpkgs/trunk/; revision=21394
2010-04-28 09:40:19 +01:00
neon = neon029;
* Added Subversion 1.5.0. Some features probably don't work yet (building the Apache modules, building various language bindings). * Neon 0.28.2. Also kept Neon 0.26.x because Subversion 1.4.x needs it. svn path=/nixpkgs/trunk/; revision=12162
2008-06-19 16:29:25 +01:00
bdbSupport = getConfig ["subversion" "bdbSupport"] true;
httpServer = getConfig ["subversion" "httpServer"] false;
httpSupport = getConfig ["subversion" "httpSupport"] true;
sslSupport = getConfig ["subversion" "sslSupport"] true;
pythonBindings = getConfig ["subversion" "pythonBindings"] false;
perlBindings = getConfig ["subversion" "perlBindings"] false;
subversion: enable Java bindings only on those platforms that support a JDK svn path=/nixpkgs/trunk/; revision=17599
2009-10-02 13:44:54 +01:00
javahlBindings = supportsJDK && getConfig ["subversion" "javahlBindings"] false;
* Added Subversion 1.5.0. Some features probably don't work yet (building the Apache modules, building various language bindings). * Neon 0.28.2. Also kept Neon 0.26.x because Subversion 1.4.x needs it. svn path=/nixpkgs/trunk/; revision=12162
2008-06-19 16:29:25 +01:00
compressionSupport = getConfig ["subversion" "compressionSupport"] true;
* Drop pkgsOverriden. svn path=/nixpkgs/trunk/; revision=22823
2010-07-30 13:10:24 +01:00
httpd = apacheHttpd;
* Added Subversion 1.5.0. Some features probably don't work yet (building the Apache modules, building various language bindings). * Neon 0.28.2. Also kept Neon 0.26.x because Subversion 1.4.x needs it. svn path=/nixpkgs/trunk/; revision=12162
2008-06-19 16:29:25 +01:00
};
* Drop the "perl" prefix from Perl attribute names. It's redundant now that Perl packages are in their own namespace (perlPackages.<pkg>). svn path=/nixpkgs/trunk/; revision=15176
2009-04-20 13:49:35 +01:00
svk = perlPackages.SVK;
Added SVK. svn path=/nixpkgs/trunk/; revision=11937
2008-05-30 19:15:25 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
sylpheed = callPackage ../applications/networking/mailreaders/sylpheed {
sylpheed 2.4.1 svn path=/nixpkgs/trunk/; revision=8681
2007-05-14 01:29:30 +01:00
inherit (gtkLibs) gtk;
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
sslSupport = true;
gpgSupport = true;
add xterm. Untested in NixOS (but will be in 10 minutes) svn path=/nixpkgs/trunk/; revision=4604
2006-01-26 20:45:11 +00:00
};
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01: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 17:26:58 +01:00
synergy = callPackage ../applications/misc/synergy { };
Synergy added and fetchcvs modified (see mailinglist post) svn path=/nixpkgs/trunk/; revision=9624
2007-11-11 08:16:23 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
tahoelafs = callPackage ../tools/networking/p2p/tahoe-lafs {
Add Tahoe, a decentralized, fault-tolerant file system. svn path=/nixpkgs/trunk/; revision=16082
2009-06-28 22:03:00 +01:00
inherit (pythonPackages) twisted foolscap simplejson nevow zfec
Tahoe-LAFS 1.6.0. svn path=/nixpkgs/trunk/; revision=19784
2010-02-03 13:38:03 +00:00
pycryptopp pysqlite darcsver setuptoolsTrial setuptoolsDarcs
pkgs/tools/networking/p2p/tahoe-lafs: updated to version 1.7.1 svn path=/nixpkgs/trunk/; revision=22774
2010-07-28 00:52:22 +01:00
numpy pyasn1;
pkgs/tools/networking/p2p/tahoe-lafs: add mock060 to propagatedBuildInputs The package is required for the regression test suite. Adding it to buildInputs would probably work, too, but I haven't tried it. svn path=/nixpkgs/trunk/; revision=22792
2010-07-28 14:09:20 +01:00
mock = pythonPackages.mock060;
Add Tahoe, a decentralized, fault-tolerant file system. svn path=/nixpkgs/trunk/; revision=16082
2009-06-28 22:03:00 +01:00
};
Remove multiversion expression for tailor for easier use of custom versions svn path=/nixpkgs/trunk/; revision=15296
2009-04-25 12:19:42 +01:00
tailor = builderDefsPackage (import ../applications/version-management/tailor) {
Upgrade default to python version 2.5.x. svn path=/nixpkgs/trunk/; revision=12910
2008-09-24 09:50:32 +01:00
inherit makeWrapper python;
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
all-packages.nix changes; now builderDefsPackage includes .meta.function attribute svn path=/nixpkgs/trunk/; revision=11767
2008-05-07 08:23:20 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
tangogps = callPackage ../applications/misc/tangogps {
Add tangoGPS, a friendly GPS and map user interface. svn path=/nixpkgs/trunk/; revision=15840
2009-06-03 14:52:38 +01:00
inherit (gtkLibs) gtk;
gconf = gnome.GConf;
};
Unfinished teamspeak client svn path=/nixpkgs/trunk/; revision=9934
2007-12-14 01:50:19 +00:00
/* does'nt work yet i686-linux only (32bit 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 17:26:58 +01:00
teamspeak_client = callPackage ../applications/networking/instant-messengers/teamspeak/client.nix { };
Unfinished teamspeak client svn path=/nixpkgs/trunk/; revision=9934
2007-12-14 01:50:19 +00:00
*/
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
taskJuggler = callPackage ../applications/misc/taskjuggler {
Add TaskJuggler: A project management tool. svn path=/nixpkgs/trunk/; revision=11933
2008-05-29 20:12:53 +01:00
qt = qt3;
# KDE support is not working yet.
Move KDE 3 packages into kde3 set Use kde3.kile instead of kile etc. svn path=/nixpkgs/trunk/; revision=20910
2010-04-01 14:34:36 +01:00
inherit (kde3) kdelibs kdebase;
withKde = getPkgConfig "taskJuggler" "kde" false;
Add TaskJuggler: A project management tool. svn path=/nixpkgs/trunk/; revision=11933
2008-05-29 20:12:53 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
thinkingRock = callPackage ../applications/misc/thinking-rock { };
added thinkingRock svn path=/nixpkgs/trunk/; revision=13993
2009-02-06 03:14:30 +00:00
* Make Thunderbird 3.x the default. svn path=/nixpkgs/trunk/; revision=22749
2010-07-27 12:46:03 +01:00
thunderbird = thunderbird3;
* Thunderbird 3.0. It doesn't use the Xulrunner package, as building against an external Xulrunner seems to be unsupported currently. svn path=/nixpkgs/trunk/; revision=19169
2010-01-02 13:21:50 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
thunderbird2 = callPackage ../applications/networking/mailreaders/thunderbird/2.x.nix {
* Thunderbird 2.0.0.0. svn path=/nixpkgs/trunk/; revision=8820
2007-06-02 21:32:24 +01:00
inherit (gtkLibs) gtk;
inherit (gnome) libIDL;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
thunderbird3 = callPackage ../applications/networking/mailreaders/thunderbird/3.x.nix {
* Thunderbird 3.0. It doesn't use the Xulrunner package, as building against an external Xulrunner seems to be unsupported currently. svn path=/nixpkgs/trunk/; revision=19169
2010-01-02 13:21:50 +00:00
inherit (gtkLibs) gtk;
Updated Squid svn path=/nixpkgs/trunk/; revision=14451
2009-03-08 12:29:34 +00:00
inherit (gnome) libIDL;
svn path=/nixpkgs/trunk/; revision=22824
2010-07-30 13:24:19 +01:00
};
Updated Squid svn path=/nixpkgs/trunk/; revision=14451
2009-03-08 12:29:34 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
timidity = callPackage ../tools/misc/timidity { };
Added TiMidity MIDI renderer svn path=/nixpkgs/trunk/; revision=9359
2007-09-23 15:47:11 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
tkcvs = callPackage ../applications/version-management/tkcvs { };
Adding tkcvs (which manages also subversion repositories well, they claim) svn path=/nixpkgs/trunk/; revision=16008
2009-06-19 10:02:48 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
tla = callPackage ../applications/version-management/arch { };
Add GNU Arch (tla). svn path=/nixpkgs/trunk/; revision=10714
2008-02-17 13:44:30 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
transmission = callPackage ../applications/networking/p2p/transmission {
applications/networking/p2p/transmission: New nixpkg. svn path=/nixpkgs/trunk/; revision=20840
2010-03-28 00:06:30 +00:00
inherit (gtkLibs) gtk;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
twinkle = callPackage ../applications/networking/twinkle {
adding twinkle, a voice over IP phone software svn path=/nixpkgs/trunk/; revision=17303
2009-09-20 18:01:19 +01:00
qt = qt3;
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 17:26:58 +01:00
unison = callPackage ../applications/networking/sync/unison { };
* add unison - unison uses a wrapper script to add font-schumacher-misc to the local X font path if the font isn't already present; this is necessary for it to work, but not terribly nice ... * lablgtk is a dependency of unison - handling of library dirs with ocaml is a hack so far; in principle, ocaml needs a general setup for library dirs like ghc svn path=/nixpkgs/trunk/; revision=9094
2007-08-10 09:21:31 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
uucp = callPackage ../tools/misc/uucp { };
all-packages.nix changes for all the previous commits svn path=/nixpkgs/trunk/; revision=11564
2008-04-11 10:32:27 +01:00
Adding uzbl - a tiny browser svn path=/nixpkgs/trunk/; revision=16006
2009-06-19 09:05:21 +01:00
uzbl = builderDefsPackage (import ../applications/networking/browsers/uzbl) {
Forgot makeWrapper input to uzbl svn path=/nixpkgs/trunk/; revision=16550
2009-08-03 07:27:20 +01:00
inherit pkgconfig webkit makeWrapper;
* Make GTK 2.18 the default, and get rid of the deep overrides. (BTW, there seems to be a much cleaner solution than deepOverride, namely call all-packages.nix with an appropriate packageOverrides set.) svn path=/nixpkgs/branches/xorg-7.5/; revision=18025
2009-10-29 14:19:13 +00:00
inherit (gtkLibs) gtk glib;
Fix some strange Uzbl library problem svn path=/nixpkgs/trunk/; revision=22310
2010-06-17 16:23:38 +01:00
inherit (xlibs) libX11;
Make WebKit use libsoup 2.31.2 via deepOverride. Edit a few packages that were overridable but did not allow extra arguments. Remove a catch with deepOverride that pkgs.lib had this attribute in a different sense. svn path=/nixpkgs/trunk/; revision=22529
2010-07-08 14:25:52 +01:00
libsoup = gnome28.libsoup_2_31;
Adding uzbl - a tiny browser svn path=/nixpkgs/trunk/; revision=16006
2009-06-19 09:05:21 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
valknut = callPackage ../applications/networking/p2p/valknut {
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
qt = qt3;
};
Make eclipse reusable: function of plugins to eclipse svn path=/nixpkgs/trunk/; revision=4887
2006-02-24 21:42:57 +00:00
Add Veracity distributed VCS (+ issue tracker) svn path=/nixpkgs/trunk/; revision=23031
2010-08-07 23:44:25 +01:00
veracity = callPackage ../applications/version-management/veracity {};
Moved monotone packages to a more appropriate position within all-packages.nix svn path=/nixpkgs/trunk/; revision=19144
2009-12-29 11:57:27 +00:00
viewMtn = builderDefsPackage (import ../applications/version-management/viewmtn/0.10.nix)
{
pkgs/top-level/all-packages.nix: stripped trailing whitespace svn path=/nixpkgs/trunk/; revision=23140
2010-08-12 12:22:06 +01:00
inherit
flup and ViewMTN seem to work just as well with default Python svn path=/nixpkgs/trunk/; revision=23119
2010-08-11 17:28:53 +01:00
monotone flup cheetahTemplate highlight ctags
Moved monotone packages to a more appropriate position within all-packages.nix svn path=/nixpkgs/trunk/; revision=19144
2009-12-29 11:57:27 +00:00
makeWrapper graphviz which 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 17:26:58 +01:00
vim = callPackage ../applications/editors/vim { };
* eclipse-sdk: added support for plugins * Added Spoofax editor plugin. * re-added eclipse-sdk 3.1, which wasn't necessary after all. svn path=/nixpkgs/trunk/; revision=4255
2005-11-07 23:02:17 +00:00
* Turn vim/default.nix into a regular package. We don't need two configurable VIMs. svn path=/nixpkgs/trunk/; revision=22784
2010-07-28 13:52:54 +01:00
vimHugeX = vim_configurable;
Included some configuration for Vim. svn path=/nixpkgs/trunk/; revision=9099
2007-08-10 20:53:30 +01:00
fix svn path=/nixpkgs/trunk/; revision=9932
2007-12-13 22:30:31 +00:00
vim_configurable = import ../applications/editors/vim/configurable.nix {
Make configurable Vim build with most options svn path=/nixpkgs/trunk/; revision=22924
2010-08-03 11:59:57 +01:00
inherit fetchurl stdenv ncurses pkgconfig gettext composableDerivation lib;
vim_configurable example added. broken see comment. svn path=/nixpkgs/trunk/; revision=9923
2007-12-12 07:20:41 +00:00
inherit (xlibs) libX11 libXext libSM libXpm
Make configurable Vim build with most options svn path=/nixpkgs/trunk/; revision=22924
2010-08-03 11:59:57 +01:00
libXt libXaw libXau libXmu libICE;
vim_configurable example added. broken see comment. svn path=/nixpkgs/trunk/; revision=9923
2007-12-12 07:20:41 +00:00
inherit (gtkLibs) glib gtk;
features = "huge"; # one of tiny, small, normal, big or huge
# optional features by passing
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
# python
vim_configurable example added. broken see comment. svn path=/nixpkgs/trunk/; revision=9923
2007-12-12 07:20:41 +00:00
# TODO mzschemeinterp perlinterp
fix perl, ruby, tcl support in vim_configurable svn path=/nixpkgs/trunk/; revision=14052
2009-02-12 20:27:54 +00:00
inherit python perl tcl ruby /*x11*/;
vim_configurable example added. broken see comment. svn path=/nixpkgs/trunk/; revision=9923
2007-12-12 07:20:41 +00:00
Make configurable Vim build with most options svn path=/nixpkgs/trunk/; revision=22924
2010-08-03 11:59:57 +01:00
lua = lua5;
vim_configurable example added. broken see comment. svn path=/nixpkgs/trunk/; revision=9923
2007-12-12 07:20:41 +00:00
# optional features by flags
flags = [ "X11" ]; # only flag "X11" 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 17:26:58 +01:00
virtualgl = callPackage ../tools/X11/virtualgl { };
Adding virtualgl (and therefore, libjpeg-turbo, a SIMD API-compatible libjpeg) svn path=/nixpkgs/trunk/; revision=22553
2010-07-10 09:45:44 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
vlc = callPackage ../applications/video/vlc {
* MPlayer: updated to the SVN version. * VLC: updated to 0.9.8a. It now uses Qt for the GUI, which looks a lot better than the wxWidgets one. * libdvdread, libdvdnav: updated to 4.1.3. * ffmpeg: updated to 0.5 (a new release!). Got rid of the SVN version, which shouldn't be necessary anymore. svn path=/nixpkgs/trunk/; revision=14500
2009-03-10 21:03:51 +00:00
dbus = dbus.libs;
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
alsa = alsaLib;
New VLC, ffmpeg, x264 and libvpx all-in-one-rebuild. VP8 support. svn path=/nixpkgs/trunk/; revision=22410
2010-06-24 23:55:25 +01:00
lua = lua5;
* development/libraries/gnome/*: upgraded all gnome packages to 2.8.3. * development/libraries/gnome/*: copied gtk packages to gnome directory. gnome 2.8.3 did not work on gtk 2.4 nor gtk 2.6. Using the specific version of the gnome platform 2.8.3 directory 'solved' the issue. * development/libraries/gnome/gnome-icon-theme: new packag * development/libraries/gnome/libgtkhtml: new package * development/libraries/gnome/gtkhtml: new package * development/libraries/gnome/libgnomeprint: new package * development/libraries/gnome/libgnomeprintui: new package * development/libraries/gnome/gnome-keyring: new package * development/libraries/gnome/gail: new package * applications/editors/monodoc: new package svn path=/nixpkgs/trunk/; revision=2312
2005-02-26 23:45:19 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
vnstat = callPackage ../applications/networking/vnstat { };
Adding vnstat. Unless using "vnstat -l", it wants some directories in /var, where it collects information. svn path=/nixpkgs/trunk/; revision=17753
2009-10-12 12:08:52 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
vorbisTools = callPackage ../applications/audio/vorbis-tools { };
Add Vorbis Tools. svn path=/nixpkgs/trunk/; revision=10628
2008-02-11 22:39:54 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
vwm = callPackage ../applications/window-managers/vwm { };
Adding vwm, the console window manager. svn path=/nixpkgs/trunk/; revision=15255
2009-04-22 22:33:24 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
w3m = callPackage ../applications/networking/browsers/w3m {
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
graphicsSupport = false;
* development/libraries/gnome/*: upgraded all gnome packages to 2.8.3. * development/libraries/gnome/*: copied gtk packages to gnome directory. gnome 2.8.3 did not work on gtk 2.4 nor gtk 2.6. Using the specific version of the gnome platform 2.8.3 directory 'solved' the issue. * development/libraries/gnome/gnome-icon-theme: new packag * development/libraries/gnome/libgtkhtml: new package * development/libraries/gnome/gtkhtml: new package * development/libraries/gnome/libgnomeprint: new package * development/libraries/gnome/libgnomeprintui: new package * development/libraries/gnome/gnome-keyring: new package * development/libraries/gnome/gail: new package * applications/editors/monodoc: new package svn path=/nixpkgs/trunk/; revision=2312
2005-02-26 23:45:19 +00:00
};
* Added weechat and updated xfce-terminal and vte. (From Graeme Caldwell <graemercaldwell@gmail.com>.) svn path=/nixpkgs/trunk/; revision=22965
2010-08-05 16:47:15 +01: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 17:26:58 +01:00
wings = callPackage ../applications/graphics/wings { };
Adding Wings 3D (as a side effect, update erlang, and add esdl). svn path=/nixpkgs/trunk/; revision=22436
2010-07-01 10:08:37 +01:00
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
# I'm keen on wmiimenu only >wmii-3.5 no longer has it...
added: dnsmasq, uisp, fltk libixp_for_wmii, acerhk kernel module, reiserfsprogs, radeontools, msmtp, procmail, pstree, gxemul changed: umlutilities to also support building tunctl optionally (needing kernel header files) wmii updated and wmiimenu added svn path=/nixpkgs/trunk/; revision=9242
2007-09-03 13:10:57 +01:00
wmiimenu = import ../applications/window-managers/wmii31 {
removed libixp-0.3 (wmiimenu does also build with 0.4) wmii updated svn path=/nixpkgs/trunk/; revision=12011
2008-06-08 22:41:07 +01:00
libixp = libixp_for_wmii;
added: dnsmasq, uisp, fltk libixp_for_wmii, acerhk kernel module, reiserfsprogs, radeontools, msmtp, procmail, pstree, gxemul changed: umlutilities to also support building tunctl optionally (needing kernel header files) wmii updated and wmiimenu added svn path=/nixpkgs/trunk/; revision=9242
2007-09-03 13:10:57 +01:00
inherit fetchurl /* fetchhg */ stdenv gawk;
inherit (xlibs) libX11;
};
wmiiSnap = import ../applications/window-managers/wmii {
libixp = libixp_for_wmii;
Revert "update wmii. libixp vanished" The new wmii has some wired behaviour: - When you move windows the curser location changes. Until the window manager has changed that location movement of mouse is ignored. - window do not always popup in the col which was focused. - wmiimenu broke old wmii does not build with newer libixp Until I know how to fix those issues I'll revert my update This reverts -r 21683 svn path=/nixpkgs/trunk/; revision=21816
2010-05-17 14:35:38 +01:00
inherit fetchurl /* fetchhg */ stdenv gawk;
inherit (xlibs) libX11 xextproto libXt libXext;
removed libixp-0.3 (wmiimenu does also build with 0.4) wmii updated svn path=/nixpkgs/trunk/; revision=12011
2008-06-08 22:41:07 +01:00
includeUnpack = getConfig ["stdenv" "includeUnpack"] false;
add wmii window manager + all dependencies. Interesting excercise... svn path=/nixpkgs/trunk/; revision=8338
2007-03-18 23:58:22 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
wordnet = callPackage ../applications/misc/wordnet { };
Add WordNet, a lexical database for English. svn path=/nixpkgs/trunk/; revision=10659
2008-02-13 14:26:01 +00:00
* Refactor the Firefox directories a bit. svn path=/nixpkgs/trunk/; revision=16143
2009-07-02 15:26:24 +01:00
wrapFirefox = browser: browserName: nameSuffix: import ../applications/networking/browsers/firefox/wrapper.nix {
Added desktop file generation function and desktop item for firefox svn path=/nixpkgs/trunk/; revision=15529
2009-05-10 13:03:53 +01:00
inherit stdenv nameSuffix makeWrapper makeDesktopItem browser browserName;
wrapFirefox: Use GNU Gnash as the default Flash player, allow use of Adobe Flash through the `firefox.enableAdobeFlash' Nixpkgs config attribute. svn path=/nixpkgs/trunk/; revision=11037
2008-03-10 15:13:06 +00:00
plugins =
Updating flashplayer10 for i686, and adding it for x64. I haven't tried the builder for i686, but I think it should work. The fix should be easy in any cas. I don't think I've written pretty nix code, so I'm looking forward for revision. svn path=/nixpkgs/trunk/; revision=14324
2009-03-04 11:04:16 +00:00
let enableAdobeFlash = getConfig [ browserName "enableAdobeFlash" ] true;
wrapFirefox: Use GNU Gnash as the default Flash player, allow use of Adobe Flash through the `firefox.enableAdobeFlash' Nixpkgs config attribute. svn path=/nixpkgs/trunk/; revision=11037
2008-03-10 15:13:06 +00:00
in
([]
* Clean up indentation (expanded tabs etc.). svn path=/nixpkgs/trunk/; revision=11150
2008-03-17 09:41:28 +00:00
++ lib.optional (!enableAdobeFlash) gnash
* Added gecko-mediaplayer, a browser plugin that uses gnome-mplayer to play video. Seems to be more stable than mplayerplug-in. svn path=/nixpkgs/trunk/; revision=16379
2009-07-15 21:34:08 +01:00
++ lib.optional enableAdobeFlash flashplayer
* Clean up indentation (expanded tabs etc.). svn path=/nixpkgs/trunk/; revision=11150
2008-03-17 09:41:28 +00:00
# RealPlayer is disabled by default for legal reasons.
Allow `wrapFirefox' to read per-browser options. svn path=/nixpkgs/trunk/; revision=12889
2008-09-19 10:46:21 +01:00
++ lib.optional (system != "i686-linux" && getConfig [browserName "enableRealPlayer"] false) RealPlayer
* Disable the MPlayer plugin (for now?) because it's not entirely stable and doesn't compile on Firefox 3.5 yet. svn path=/nixpkgs/trunk/; revision=16313
2009-07-10 13:10:58 +01:00
++ lib.optional (getConfig [browserName "enableMPlayer"] false) (MPlayerPlugin browser)
* Added gecko-mediaplayer, a browser plugin that uses gnome-mplayer to play video. Seems to be more stable than mplayerplug-in. svn path=/nixpkgs/trunk/; revision=16379
2009-07-15 21:34:08 +01:00
++ lib.optional (getConfig [browserName "enableGeckoMediaPlayer"] false) gecko_mediaplayer
Allow `wrapFirefox' to read per-browser options. svn path=/nixpkgs/trunk/; revision=12889
2008-09-19 10:46:21 +01:00
++ lib.optional (supportsJDK && getConfig [browserName "jre"] false && jrePlugin ? mozillaPlugin) jrePlugin
* Clean up indentation (expanded tabs etc.). svn path=/nixpkgs/trunk/; revision=11150
2008-03-17 09:41:28 +00:00
);
Finally, a real text editor in Nix. Todo: allow configuration with modes. svn path=/nixpkgs/trunk/; revision=1543
2004-10-06 12:32:20 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
x11vnc = callPackage ../tools/X11/x11vnc { };
- svn path=/nixpkgs/branches/stdenv-updates-merge/; revision=10823
2008-02-22 03:06:12 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
x2vnc = callPackage ../tools/X11/x2vnc { };
Added x2vnc, a tool to control physically close but formally remote VNC display as an extension of local one. svn path=/nixpkgs/trunk/; revision=11148
2008-03-17 06:29:32 +00:00
Added XaoS fractal viewer svn path=/nixpkgs/trunk/; revision=14004
2009-02-08 14:17:05 +00:00
xaos = builderDefsPackage (import ../applications/graphics/xaos) {
inherit (xlibs) libXt libX11 libXext xextproto xproto;
inherit gsl aalib zlib libpng intltool gettext perl;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
xara = callPackage ../applications/graphics/xara {
* Emacs 22.0.50 (CVS dump). svn path=/nixpkgs/trunk/; revision=4359
2005-12-13 00:13:01 +00:00
inherit (gtkLibs) gtk;
Fixing some wxGTK dangling attributes I forgot in a recent commit. svn path=/nixpkgs/trunk/; revision=18162
2009-11-05 21:34:44 +00:00
wxGTK = wxGTK26;
* Emacs 22.0.50 (CVS dump). svn path=/nixpkgs/trunk/; revision=4359
2005-12-13 00:13:01 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xawtv = callPackage ../applications/video/xawtv { };
* Added the Emacs 22.0 branch with anti-aliasing (Xft) support. * Added an option to Adobe Reader to make it start faster (by deleting all the plugins). svn path=/nixpkgs/trunk/; revision=4406
2005-12-22 10:49:43 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
xchat = callPackage ../applications/networking/irc/xchat {
xchat 2.8.2, cleanups svn path=/nixpkgs/trunk/; revision=8679
2007-05-14 01:13:48 +01:00
inherit (gtkLibs) gtk;
* nxml package. svn path=/nixpkgs/trunk/; revision=578
2003-12-08 11:56:50 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xchm = callPackage ../applications/misc/xchm { };
Upgraded nxml mode and added cua mode svn path=/nixpkgs/trunk/; revision=1544
2004-10-06 13:06:23 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xcompmgr = callPackage ../applications/window-managers/xcompmgr { };
applications/window-managers/xcompmgr: New package. svn path=/nixpkgs/trunk/; revision=19272
2010-01-06 20:45:43 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xdg_utils = callPackage ../tools/X11/xdg-utils { };
* Added xdg-utils, a package that contains desktop integration commands such as `xdg-open' (which opens a URL with the user's default browser). svn path=/nixpkgs/trunk/; revision=20829
2010-03-25 19:48:06 +00:00
Some of preparation work for adding Xen. Troubles: 1. Xen Dom0 support not complete in mainline. 2. Xen's love to check for headers in /usr/include. To do afterwards: We need to change bootloading setup a bit. svn path=/nixpkgs/trunk/; revision=12941
2008-10-04 16:24:08 +01:00
/* Doesn't work yet
maudeUnstable: updated full-maude to latest alpha release svn path=/nixpkgs/trunk/; revision=13017
2008-10-09 11:10:49 +01:00
Some of preparation work for adding Xen. Troubles: 1. Xen Dom0 support not complete in mainline. 2. Xen's love to check for headers in /usr/include. To do afterwards: We need to change bootloading setup a bit. svn path=/nixpkgs/trunk/; revision=12941
2008-10-04 16:24:08 +01:00
xen = builderDefsPackage (import ../applications/virtualization/xen) {
inherit python e2fsprogs gnutls pkgconfig libjpeg
ncurses SDL libvncserver zlib;
texLive = if (getConfig ["xen" "texLive"] false) then texLive else null;
graphviz = if (getConfig ["xen" "graphviz"] false) then graphviz else null;
ghostscript = if (getConfig ["xen" "ghostscript"] false) then ghostscript else null;
}; */
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
xfig = callPackage ../applications/graphics/xfig {
* Merge the new generic builder. * Removed substitute, it's part of the generic builder now. * stdenv-initial (Linux): use the real generic builder script. This does require that sed is in the path of the builder of the initial stdenv. svn path=/nixpkgs/trunk/; revision=7498
2006-12-27 18:14:57 +00:00
stdenv = overrideGCC stdenv gcc34;
* By popular demand: xfig. svn path=/nixpkgs/trunk/; revision=7278
2006-12-08 01:17:21 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xineUI = callPackage ../applications/video/xine-ui { };
Haskell mode for emacs svn path=/nixpkgs/trunk/; revision=1832
2004-12-06 07:36:56 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
xmms = callPackage ../applications/audio/xmms {
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
inherit (gnome) esound;
inherit (gtkLibs1x) glib gtk;
stdenv = overrideGCC stdenv gcc34; # due to problems with gcc 4.x
emacs, vim, nano ... Nix is af. svn path=/nixpkgs/trunk/; revision=1545
2004-10-06 14:17:06 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
xneur = callPackage ../applications/misc/xneur {
all-packages.nix changes for previous commits svn path=/nixpkgs/trunk/; revision=11217
2008-03-20 09:52:40 +00:00
GStreamer=gst_all.gstreamer;
Update XNeur svn path=/nixpkgs/trunk/; revision=16589
2009-08-05 11:25:17 +01:00
inherit (gtkLibs) glib gtk pango atk;
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
};
all-packages.nix changes for previous commits svn path=/nixpkgs/trunk/; revision=11217
2008-03-20 09:52:40 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
xneur_0_8 = callPackage ../applications/misc/xneur/0.8.nix {
* Replace some "inherit (gtkLibs) glib" statements with "inherit glib". svn path=/nixpkgs/trunk/; revision=18013
2009-10-29 11:43:02 +00:00
GStreamer = gst_all.gstreamer;
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
};
all-packages.nix changes for previous commits svn path=/nixpkgs/trunk/; revision=11217
2008-03-20 09:52:40 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
xournal = callPackage ../applications/graphics/xournal {
Adding Xournal - a note-taking application for stylus usage svn path=/nixpkgs/trunk/; revision=16538
2009-08-02 22:47:10 +01:00
inherit (gtkLibs) gtk atk pango glib;
xlock: fixed build and updated to version 5.24 svn path=/nixpkgs/trunk/; revision=17356
2009-09-22 21:16:38 +01:00
inherit (gnome) libgnomeprint libgnomeprintui
Adding Xournal - a note-taking application for stylus usage svn path=/nixpkgs/trunk/; revision=16538
2009-08-02 22:47:10 +01:00
libgnomecanvas;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
xpdf = callPackage ../applications/misc/xpdf {
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
motif = lesstif;
* xpdf updated to 3.02pl1. Also patch its configuration file so that it uses the Base-14 fonts from Ghostscript. svn path=/nixpkgs/trunk/; revision=9396
2007-10-03 13:16:48 +01:00
base14Fonts = "${ghostscript}/share/ghostscript/fonts";
statically linked nano. For some reason I had to use the --enable-tiny configure flag, so the full blown normal glibc dynamically linked version is a bit less functional now, but it is only intended to be used in rescue mode anyway, since normal people use vi. svn path=/nixpkgs/trunk/; revision=6318
2006-08-30 00:40:29 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
xpra = callPackage ../tools/X11/xpra {
* Adde xpra. Doesn't quite work yet. * Removed python_alts. svn path=/nixpkgs/trunk/; revision=11161
2008-03-17 13:45:50 +00:00
inherit (gtkLibs) gtk;
pyrex = pyrex095;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
xscreensaver = callPackage ../applications/graphics/xscreensaver {
* Get rid of the `(import (__toPath ((toString ./JustNothing/.. )+"/"+args.version+".nix")))' hack, you can also just write `import (./path/to/pkg + "/${version}.nix)'. svn path=/nixpkgs/trunk/; revision=9792
2007-11-26 13:24:56 +00:00
inherit (gtkLibs) gtk;
inherit (gnome) libglade;
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
Added XScreensaver; also changed version-stub.nix (now it does sumArgs itself, and requires builderDefs to be used) and added a merge of composing-builder and declarative flag processing. svn path=/nixpkgs/trunk/; revision=9776
2007-11-22 20:26:00 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xterm = callPackage ../applications/misc/xterm { };
* User-Mode Linux and GNU Patch. svn path=/nixpkgs/trunk/; revision=779
2004-02-13 14:42:28 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xtrace = callPackage ../tools/X11/xtrace { };
Adding xtrace (not that of glibc, but a X protocol tracer) svn path=/nixpkgs/trunk/; revision=19013
2009-12-17 11:58:05 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xlaunch = callPackage ../tools/X11/xlaunch { };
Fixed bridge-utils, added qemu, tuned builder-defs unpack, added xlaunch - a tool to launch X using everything possible from the job except slim. svn path=/nixpkgs/trunk/; revision=9985
2007-12-31 08:49:41 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xmacro = callPackage ../tools/X11/xmacro { };
Added xmacro; updated clisp - well, it compiles now... svn path=/nixpkgs/trunk/; revision=9098
2007-08-10 19:54:44 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xmove = callPackage ../applications/misc/xmove { };
Fixed bridge-utils, added qemu, tuned builder-defs unpack, added xlaunch - a tool to launch X using everything possible from the job except slim. svn path=/nixpkgs/trunk/; revision=9985
2007-12-31 08:49:41 +00:00
Added xnee utility for X11 action recording svn path=/nixpkgs/trunk/; revision=12612
2008-08-14 10:25:26 +01:00
xnee = builderDefsPackage (import ../tools/X11/xnee) {
inherit (gtkLibs) gtk;
bison: use version 2.3 by default (the latest) svn path=/nixpkgs/trunk/; revision=12703
2008-08-25 14:25:07 +01:00
inherit (xlibs) libX11 libXtst xextproto libXext
Added xnee utility for X11 action recording svn path=/nixpkgs/trunk/; revision=12612
2008-08-14 10:25:26 +01:00
inputproto libXi xproto recordproto;
inherit pkgconfig;
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
Added xnee utility for X11 action recording svn path=/nixpkgs/trunk/; revision=12612
2008-08-14 10:25:26 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
xvidcap = callPackage ../applications/video/xvidcap {
* Xvidcap for making screen recordings. svn path=/nixpkgs/trunk/; revision=7186
2006-12-01 16:44:26 +00:00
inherit (gtkLibs) gtk;
inherit (gnome) scrollkeeper libglade;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
yate = callPackage ../applications/misc/yate {
adding yate2 telephony engine svn path=/nixpkgs/trunk/; revision=17861
2009-10-18 05:43:48 +01:00
qt = qt4;
};
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
# doesn't compile yet - in case someone else want's to continue ..
t/gis/qgis updating qgis Signed-off-by: Marc Weber <marco-oweber@gmx.de> svn path=/nixpkgs/trunk/; revision=22115
2010-06-03 01:51:23 +01:00
# use Trunk because qgisReleased segfaults no resize for now
qgis = qgisTrunk;
qgisReleased = (import ../applications/misc/qgis) {
removed mkDerivationByConfiguration, using composableDerivation instead qgis, vim_configurable both work now svn path=/nixpkgs/trunk/; revision=13661
2008-12-20 01:20:35 +00:00
inherit composableDerivation fetchsvn stdenv flex lib
hddtemp (tool to get harddisk temperatures) added and unfinished qgis expression (in case someone else want's to continue working on it) svn path=/nixpkgs/trunk/; revision=9903
2007-12-10 22:36:52 +00:00
ncurses fetchurl perl cmake gdal geos proj x11
bison: use version 2.3 by default (the latest) svn path=/nixpkgs/trunk/; revision=12703
2008-08-25 14:25:07 +01:00
gsl libpng zlib bison
t/gis/qgis updating qgis Signed-off-by: Marc Weber <marco-oweber@gmx.de> svn path=/nixpkgs/trunk/; revision=22115
2010-06-03 01:51:23 +01:00
sqlite glibc fontconfig freetype /* use libc from stdenv ? - to lazy now - Marc */
python postgresql pyqt4;
hddtemp (tool to get harddisk temperatures) added and unfinished qgis expression (in case someone else want's to continue working on it) svn path=/nixpkgs/trunk/; revision=9903
2007-12-10 22:36:52 +00:00
inherit (xlibs) libSM libXcursor libXinerama libXrandr libXrender;
inherit (xorg) libICE;
qt = qt4;
# optional features
# grass = "not yet supported" # cmake -D WITH_GRASS=TRUE and GRASS_PREFX=..
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
qgisTrunk = callPackage ../applications/misc/qgis/trunk.nix {
t/gis/qgis updating qgis Signed-off-by: Marc Weber <marco-oweber@gmx.de> svn path=/nixpkgs/trunk/; revision=22115
2010-06-03 01:51:23 +01:00
qgis = qgisReleased;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
zapping = callPackage ../applications/video/zapping {
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
inherit (gnome) scrollkeeper libgnomeui libglade esound;
teletextSupport = true;
jpegSupport = true;
pngSupport = true;
recordingSupport = true;
* Added NEdit. svn path=/nixpkgs/trunk/; revision=4329
2005-12-03 00:04:13 +00:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
zathura = callPackage ../applications/misc/zathura {
applications/misc/zathura: New nixbuild. svn path=/nixpkgs/trunk/; revision=22057
2010-05-29 22:15:13 +01:00
inherit (gtkLibs) gtk;
};
* Added NEdit. svn path=/nixpkgs/trunk/; revision=4329
2005-12-03 00:04:13 +00:00
* Fixed Stratego. * Added Zoom, an interpreter for Z-Code. svn path=/nixpkgs/trunk/; revision=894
2004-04-01 17:02:53 +01:00
### GAMES
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ballAndPaddle = callPackage ../games/ball-and-paddle { };
Add GNU Ball and Paddle, the ultimate game. svn path=/nixpkgs/trunk/; revision=12938
2008-10-04 11:08:59 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
blackshades = callPackage ../games/blackshades { };
Adding Black Shades svn path=/nixpkgs/trunk/; revision=22520
2010-07-07 23:22:19 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
blackshadeselite = callPackage ../games/blackshadeselite { };
Adding Black Shades Elite (a fork of Black Shades) svn path=/nixpkgs/trunk/; revision=22538
2010-07-08 19:06:01 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
bsdgames = callPackage ../games/bsdgames { };
Adding bsdgames and miscfiles (this later, for 'words') I could not easily make some bsdgames build or install. Too much patching against the installer trying to write beyond the nix store. svn path=/nixpkgs/trunk/; revision=17971
2009-10-26 23:03:36 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
castleCombat = callPackage ../games/castle-combat { };
Add Castle-Combat, a clone of Rampart. svn path=/nixpkgs/trunk/; revision=12978
2008-10-06 23:49:37 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
construoBase = callPackage ../games/construo {
* ltrace: updated to 0.5.3. * libdbi / libdbi-drivers: updated to 0.8.3, and make it compile with SQLite. * qemu-image: fix the URL. * gdmap: make it build again (requires an older GTK+). * rlwrap: updated to 0.37. * smbfs-fuse -> fusesmb to match the upstream name. * x11vnc: updated to 0.9.10. * clearlyU: fix the URL. * Various packages: follow the coding conventions. svn path=/nixpkgs/trunk/; revision=22814
2010-07-29 19:55:16 +01:00
mesa = null;
freeglut = null;
Added PostgreSQL job. svn path=/nixpkgs/trunk/; revision=9831
2007-12-03 04:48:44 +00:00
};
* composedArgsAndFun -> makeOverridable for consistency. * Rename a few single-version packages to "default.nix". svn path=/nixpkgs/trunk/; revision=22803
2010-07-29 09:21:21 +01:00
construo = construoBase.override {
Added PostgreSQL job. svn path=/nixpkgs/trunk/; revision=9831
2007-12-03 04:48:44 +00:00
inherit mesa freeglut;
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
* Fixed Stratego. * Added Zoom, an interpreter for Z-Code. svn path=/nixpkgs/trunk/; revision=894
2004-04-01 17:02:53 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
eduke32 = callPackage ../games/eduke32 {
Added EDuke32 package to celebrate the moment that 3DRealms is dead and Duke Nukem Forever is never going to be released svn path=/nixpkgs/trunk/; revision=15601
2009-05-14 14:48:45 +01:00
inherit (gtkLibs) gtk;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
exult = callPackage ../games/exult {
* Fix the Exult build. svn path=/nixpkgs/trunk/; revision=17605
2009-10-02 14:01:31 +01:00
stdenv = overrideGCC stdenv gcc42;
add scummvm (scummvm.sf.net) svn path=/nixpkgs/trunk/; revision=6079
2006-08-09 00:39:03 +01:00
};
* Commented out exultSnapshot, will fix later. svn path=/nixpkgs/trunk/; revision=16315
2009-07-10 13:44:34 +01:00
/*
* Exult 1.4 snapshot. svn path=/nixpkgs/trunk/; revision=12349
2008-07-12 18:00:57 +01:00
exultSnapshot = lowPrio (import ../games/exult/snapshot.nix {
inherit fetchurl stdenv SDL SDL_mixer zlib libpng unzip
bison: use version 2.3 by default (the latest) svn path=/nixpkgs/trunk/; revision=12703
2008-08-25 14:25:07 +01:00
autoconf automake libtool flex bison;
* Exult 1.4 snapshot. svn path=/nixpkgs/trunk/; revision=12349
2008-07-12 18:00:57 +01:00
});
* Commented out exultSnapshot, will fix later. svn path=/nixpkgs/trunk/; revision=16315
2009-07-10 13:44:34 +01:00
*/
* Exult 1.4 snapshot. svn path=/nixpkgs/trunk/; revision=12349
2008-07-12 18:00:57 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
freedink = callPackage ../games/freedink { };
Add GNU FreeDink. svn path=/nixpkgs/trunk/; revision=21555
2010-05-02 10:27:51 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
fsg = callPackage ../games/fsg {
* Clean up indentation (expanded tabs etc.). svn path=/nixpkgs/trunk/; revision=11150
2008-03-17 09:41:28 +00:00
inherit (gtkLibs) 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 17:26:58 +01:00
wxGTK = wxGTK28.override {unicode = false;
Added Falling Sand Game and wxGTK without unicode for it. svn path=/nixpkgs/trunk/; revision=9543
2007-10-27 18:55:13 +01:00
};
* Added GemRB, a reimplementation of the Infinity Engine. svn path=/nixpkgs/trunk/; revision=8695
2007-05-14 22:47:11 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gemrb = callPackage ../games/gemrb { };
gltron = callPackage ../games/gltron { };
Adding gltron. svn path=/nixpkgs/trunk/; revision=22519
2010-07-07 22:44:09 +01:00
Added GNU Chess and XBoard svn path=/nixpkgs/trunk/; revision=13923
2009-01-31 20:09:54 +00:00
gnuchess = builderDefsPackage (import ../games/gnuchess) {
flex = flex2535;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gnugo = callPackage ../games/gnugo { };
Three Games and Perl Support for Irssi Here are four patches. Three of them add expressions for games. The fourth, irssi-perl.patch, adds perl as an input for irssi, so that one can run perl plugins in irssi. I didn't make the perl input optional, but maybe it should be to keep the irssi expression light. svn path=/nixpkgs/trunk/; revision=21813
2010-05-17 10:21:42 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gparted = callPackage ../tools/misc/gparted {
adding gparted. qparted is no longer maintained (?) svn path=/nixpkgs/trunk/; revision=17016
2009-09-10 17:57:21 +01: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 17:26:58 +01:00
hexen = callPackage ../games/hexen { };
Adding the simple port of hexen. svn path=/nixpkgs/trunk/; revision=15046
2009-04-14 23:25:14 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
kobodeluxe = callPackage ../games/kobodeluxe { };
Adding Kobo Deluxe. svn path=/nixpkgs/trunk/; revision=15045
2009-04-14 23:25:03 +01:00
Added lincity - a city simulation. And if I build houses, I build houses here. svn path=/nixpkgs/trunk/; revision=12539
2008-08-08 08:16:34 +01:00
lincity = builderDefsPackage (import ../games/lincity) {
bison: use version 2.3 by default (the latest) svn path=/nixpkgs/trunk/; revision=12703
2008-08-25 14:25:07 +01:00
inherit (xlibs) libX11 libXext xextproto
Added lincity - a city simulation. And if I build houses, I build houses here. svn path=/nixpkgs/trunk/; revision=12539
2008-08-08 08:16:34 +01:00
libICE libSM xproto;
inherit libpng zlib;
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
Added lincity - a city simulation. And if I build houses, I build houses here. svn path=/nixpkgs/trunk/; revision=12539
2008-08-08 08:16:34 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
micropolis = callPackage ../games/micropolis { };
Added: * dmenu * gftp * micropolis * byacc as a build-time dependency for micropolis contributed by baldo <baldo@quimby.lan> svn path=/nixpkgs/trunk/; revision=12526
2008-08-06 21:39:01 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
openttd = callPackage ../games/openttd {
Add new game: openttd. svn path=/nixpkgs/trunk/; revision=11553
2008-04-10 23:12:20 +01:00
zlib = zlibStatic;
};
Adding the game 'pioneers' svn path=/nixpkgs/trunk/; revision=19769
2010-02-02 22:21:56 +00:00
pioneers = import ../games/pioneers {
inherit stdenv fetchurl pkgconfig intltool;
inherit (gtkLibs) gtk /*glib gtkmm*/;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
quake3demo = callPackage ../games/quake3/wrapper {
* ioquake: updated to 1.34rc3. * rss-glx: fixed the build. * Removed the OpenGL wrapper stuff, it's no longer needed (thanks to the RUNPATH you just need to put the appropriate libGL.so in the LD_LIBRARY_PATH). svn path=/nixpkgs/trunk/; revision=12093
2008-06-14 21:55:48 +01:00
name = "quake3-demo-${quake3game.name}";
* Added a bunch of descriptions. svn path=/nixpkgs/trunk/; revision=6705
2006-10-11 17:45:55 +01:00
description = "Demo of Quake 3 Arena, a classic first-person shooter";
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
game = quake3game;
paks = [quake3demodata];
* Added basic Quake 3. Some wrapper stuff is still needed to get it to work "out of the box" with hardware acceleration and either the shareware or full PAK files. But with some hackery, I have gotten it to work with both Mesa software rendering and NVidia hardware rendering. svn path=/nixpkgs/trunk/; revision=4595
2006-01-26 14:43:05 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
quake3demodata = callPackage ../games/quake3/demo { };
* Get the Quake 3 demo data to work with the open source Quake 3. quake3/demo takes care of downloading and patching the required PAK files. quake3/wrapper calls the Quake binary with a synthesised directory of symlinks to activated PAK files. This should make it easy to plug in the commercial PAKs, or third-party mods. svn path=/nixpkgs/trunk/; revision=4611
2006-01-27 23:51:36 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
quake3game = callPackage ../games/quake3/game { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
rogue = callPackage ../games/rogue { };
* Now Nixpkgs is officially complete. svn path=/nixpkgs/trunk/; revision=7573
2007-01-08 21:19:15 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
scummvm = callPackage ../games/scummvm { };
* Unreal Tournament 2004 Demo. Also a binary-only component. An interesting complication is that we have to change the ELF type of the executable from `Linux' to `SVR4', otherwise the `ld-linux.so.2' trick to override the glibc used doesn't work (apparently `Linux' is not a recognised ELF type!). UT doesn't work with software Mesa, so right now we impurily use `/usr/lib/libGL.so'. I cannot really test whether it works with hardware Mesa, since it barfs with an error about missing OpenGL extensions. But that's probably because I'm testing this on an iBook over an SSH connection to a Linux machine. svn path=/nixpkgs/trunk/; revision=1047
2004-06-09 19:06:29 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
scorched3d = callPackage ../games/scorched3d {
Fixing some wxGTK dangling attributes I forgot in a recent commit. svn path=/nixpkgs/trunk/; revision=18162
2009-11-05 21:34:44 +00:00
wxGTK = wxGTK26;
Added Scorched3D. svn path=/nixpkgs/trunk/; revision=15108
2009-04-16 23:50:36 +01:00
};
all-packages.nix changes for my last commits svn path=/nixpkgs/trunk/; revision=13693
2009-01-03 13:44:04 +00:00
sgtpuzzles = builderDefsPackage (import ../games/sgt-puzzles) {
Update SGT puzzles and improve builderDefs processing of propagated(Native)BuildInputs after stdenv merge svn path=/nixpkgs/trunk/; revision=20093
2010-02-18 10:29:40 +00:00
inherit (gtkLibs) gtk;
SGT Puzzles now need Perl for Makefile generation svn path=/nixpkgs/trunk/; revision=19466
2010-01-15 12:00:12 +00:00
inherit pkgconfig fetchsvn perl;
all-packages.nix changes for my last commits svn path=/nixpkgs/trunk/; revision=13693
2009-01-03 13:44:04 +00:00
inherit (xlibs) libX11;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
six = callPackage ../games/six {
Three Games and Perl Support for Irssi Here are four patches. Three of them add expressions for games. The fourth, irssi-perl.patch, adds perl as an input for irssi, so that one can run perl plugins in irssi. I didn't make the perl input optional, but maybe it should be to keep the irssi expression light. svn path=/nixpkgs/trunk/; revision=21813
2010-05-17 10:21:42 +01:00
inherit (kde3) arts kdelibs;
};
Added Orbit space flight simulation. Unfortunately, it doesn't feature gravity. svn path=/nixpkgs/trunk/; revision=10249
2008-01-22 17:56:53 +00:00
# You still can override by passing more arguments.
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
spaceOrbit = callPackage ../games/orbit {
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
inherit (gnome) esound; };
Added Orbit space flight simulation. Unfortunately, it doesn't feature gravity. svn path=/nixpkgs/trunk/; revision=10249
2008-01-22 17:56:53 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
superTux = callPackage ../games/super-tux { };
Three Games and Perl Support for Irssi Here are four patches. Three of them add expressions for games. The fourth, irssi-perl.patch, adds perl as an input for irssi, so that one can run perl plugins in irssi. I didn't make the perl input optional, but maybe it should be to keep the irssi expression light. svn path=/nixpkgs/trunk/; revision=21813
2010-05-17 10:21:42 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
superTuxKart = callPackage ../games/super-tux-kart { };
Super Tux Kart, a free kart racing game. svn path=/nixpkgs/trunk/; revision=13052
2008-10-12 15:28:51 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
teeworlds = callPackage ../games/teeworlds { };
Add Teeworlds, a Worms-like game, if you see what I mean. svn path=/nixpkgs/trunk/; revision=13762
2009-01-13 19:44:11 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
tennix = callPackage ../games/tennix { };
Adding (quite blindly) some gnome packages to get gnucash built. svn path=/nixpkgs/trunk/; revision=19758
2010-02-01 19:55:03 +00:00
Added pygame and some of its dependencies. Also added Python Imaging library. svn path=/nixpkgs/trunk/; revision=9082
2007-08-09 18:33:18 +01:00
/*tpm = import ../games/thePenguinMachine {
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
inherit stdenv fetchurl pil pygame SDL;
Added pygame and some of its dependencies. Also added Python Imaging library. svn path=/nixpkgs/trunk/; revision=9082
2007-08-09 18:33:18 +01:00
python24 = 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 17:26:58 +01:00
tremulous = callPackage ../games/tremulous { };
games/tremulous: New nixpkg. svn path=/nixpkgs/trunk/; revision=22413
2010-06-25 16:09:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ultimatestunts = callPackage ../games/ultimatestunts { };
Adding Ultimate Stunts, a racing game. svn path=/nixpkgs/trunk/; revision=19088
2009-12-23 22:28:50 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
urbanterror = callPackage ../games/urbanterror { };
games/urbanterror: New nixpkg for viric. svn path=/nixpkgs/trunk/; revision=19770
2010-02-03 00:46:43 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ut2004demo = callPackage ../games/ut2004demo { };
* Quake 3 Arena Demo. The goal is to show that Nix can also be used to deploy existing binary-only components. We use the `ld-linux.so.2 PROGRAM' trick to force the use of our own glibc, and set LD_LIBRARY_PATH to point to the required libraries (X11, Mesa). Since Mesa is software-only, Q3A is rather slow. I'll have to figure out how to use the Mesa from XFree86 (X.Org), since it knows how to use DRI (or at least speak the GLX protocol). Unfortunately the xlibs people haven't modularised that part of XFree86 yet. Also, the flag `+set s_initsound 0' has to be passed to Quake to disable sound, otherwise it segfaults on startup. It doesn't do this with the normal glibc, which is strange. Maybe it tries to dynamically load some sound library or something. svn path=/nixpkgs/trunk/; revision=1046
2004-06-09 18:59:46 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
warsow = callPackage ../games/warsow {
games/warsow: Needs libjpeg62. svn path=/nixpkgs/trunk/; revision=19891
2010-02-09 23:12:47 +00:00
libjpeg = libjpeg62;
games/warsow: New package. svn path=/nixpkgs/trunk/; revision=19718
2010-01-27 22:22:35 +00:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
warzone2100 = callPackage ../games/warzone2100 {
warzone2100: New nixpkg. svn path=/nixpkgs/trunk/; revision=21582
2010-05-03 17:07:01 +01:00
flex = flex2535;
};
Added GNU Chess and XBoard svn path=/nixpkgs/trunk/; revision=13923
2009-01-31 20:09:54 +00:00
xboard = builderDefsPackage (import ../games/xboard) {
Added syslog-ng (and the eventlog library that it depends on). svn path=/nixpkgs/trunk/; revision=13988
2009-02-05 16:50:45 +00:00
inherit (xlibs) libX11 xproto libXt libXaw libSM
Update xboard svn path=/nixpkgs/trunk/; revision=18870
2009-12-10 06:55:12 +00:00
libICE libXmu libXext libXpm;
inherit gnuchess texinfo;
Added GNU Chess and XBoard svn path=/nixpkgs/trunk/; revision=13923
2009-01-31 20:09:54 +00:00
};
Added XSokoban svn path=/nixpkgs/trunk/; revision=13737
2009-01-11 22:05:19 +00: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 17:26:58 +01:00
zdoom = callPackage ../games/zdoom { };
Adding zdoom. svn path=/nixpkgs/trunk/; revision=14194
2009-02-22 22:06:34 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
zoom = callPackage ../games/zoom { };
* Latest ALSA, SDL. svn path=/nixpkgs/trunk/; revision=6500
2006-09-12 00:06:26 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
keen4 = callPackage ../games/keen4 { };
* An example of supporting legacy applications using dosbox ;-) svn path=/nixpkgs/trunk/; revision=6895
2006-10-28 23:28:35 +01:00
* Fixed Stratego. * Added Zoom, an interpreter for Z-Code. svn path=/nixpkgs/trunk/; revision=894
2004-04-01 17:02:53 +01:00
* Refactoring: move KDE and Gnome out of development/libraries into desktops. svn path=/nixpkgs/trunk/; revision=8105
2007-02-28 16:18:58 +00: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 17:26:58 +01:00
enlightenment = callPackage ../desktops/enlightenment { };
Enlightenment 0.16.8.15. Patch by John Altobelli <acocaracha@gmail.com>, minor edits by Ludovic Courtès <ludo@gnu.org>. svn path=/nixpkgs/trunk/; revision=13823
2009-01-22 22:46:39 +00:00
Recurse into gnome attrs svn path=/nixpkgs/trunk/; revision=21112
2010-04-16 06:26:27 +01:00
gnome28 = recurseIntoAttrs (import ../desktops/gnome-2.28 pkgs);
* Refactoring: move KDE and Gnome out of development/libraries into desktops. svn path=/nixpkgs/trunk/; revision=8105
2007-02-28 16:18:58 +00:00
Try using Gnome-2.28 svn path=/nixpkgs/branches/xorg-7.5/; revision=18058
2009-10-31 12:59:33 +00:00
gnome = gnome28;
Add gnome-2.28 to top-level svn path=/nixpkgs/trunk/; revision=17520
2009-09-30 06:29:08 +01:00
Adding recurseIntoAttrs for the kde3 attribute set, to have the derivations available listed by nix-env. svn path=/nixpkgs/trunk/; revision=20931
2010-04-03 11:59:26 +01:00
kde3 = recurseIntoAttrs {
* Some renaming: kde -> kde-3, kde-4 -> kde-4-old (we can delete it eventually, but it seems to contain some packages that aren't in kde-4.2 yet). svn path=/nixpkgs/trunk/; revision=14481
2009-03-10 07:58:12 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
kdelibs = callPackage ../desktops/kde-3/kdelibs {
Trying to get the gcc-4.4 cross-build also. Fixing the glibc-2.10 expression on cross-builds (which should be ported to the glibc-2.11 expression once we get "ports" there) Making kde3 and cyrus-sasl use gcc-4.3, because the strictness in gcc-4.4 does not allow them build. svn path=/nixpkgs/branches/stdenv-updates/; revision=18706
2009-11-29 23:27:35 +00:00
stdenv = overrideGCC stdenv gcc43;
* Some renaming: kde -> kde-3, kde-4 -> kde-4-old (we can delete it eventually, but it seems to contain some packages that aren't in kde-4.2 yet). svn path=/nixpkgs/trunk/; revision=14481
2009-03-10 07:58:12 +00:00
qt = qt3;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
kdebase = callPackage ../desktops/kde-3/kdebase {
Trying to get the gcc-4.4 cross-build also. Fixing the glibc-2.10 expression on cross-builds (which should be ported to the glibc-2.11 expression once we get "ports" there) Making kde3 and cyrus-sasl use gcc-4.3, because the strictness in gcc-4.4 does not allow them build. svn path=/nixpkgs/branches/stdenv-updates/; revision=18706
2009-11-29 23:27:35 +00:00
stdenv = overrideGCC stdenv gcc43;
Move KDE 3 packages into kde3 set Use kde3.kile instead of kile etc. svn path=/nixpkgs/trunk/; revision=20910
2010-04-01 14:34:36 +01:00
inherit (kde3) kdelibs;
* Some renaming: kde -> kde-3, kde-4 -> kde-4-old (we can delete it eventually, but it seems to contain some packages that aren't in kde-4.2 yet). svn path=/nixpkgs/trunk/; revision=14481
2009-03-10 07:58:12 +00:00
qt = qt3;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
arts = callPackage ../development/libraries/arts {
Move KDE 3 packages into kde3 set Use kde3.kile instead of kile etc. svn path=/nixpkgs/trunk/; revision=20910
2010-04-01 14:34:36 +01:00
qt = qt3;
inherit (gnome) glib;
inherit (kde3) kdelibs;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
k3b = callPackage ../applications/misc/k3b {
Move KDE 3 packages into kde3 set Use kde3.kile instead of kile etc. svn path=/nixpkgs/trunk/; revision=20910
2010-04-01 14:34:36 +01:00
inherit (kde3) kdelibs;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
kbasket = callPackage ../applications/misc/kbasket {
Move KDE 3 packages into kde3 set Use kde3.kile instead of kile etc. svn path=/nixpkgs/trunk/; revision=20910
2010-04-01 14:34:36 +01:00
stdenv = overrideGCC stdenv gcc43;
inherit (kde3) kdelibs;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
kile = callPackage ../applications/editors/kile {
Move KDE 3 packages into kde3 set Use kde3.kile instead of kile etc. svn path=/nixpkgs/trunk/; revision=20910
2010-04-01 14:34:36 +01:00
inherit (kde3) arts kdelibs;
qt = qt3;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
kphone = callPackage ../applications/networking/kphone {
Move KDE 3 packages into kde3 set Use kde3.kile instead of kile etc. svn path=/nixpkgs/trunk/; revision=20910
2010-04-01 14:34:36 +01:00
qt = qt3;
stdenv = overrideGCC stdenv gcc42; # I'm to lazy to clean up header files
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
kuickshow = callPackage ../applications/graphics/kuickshow {
Move KDE 3 packages into kde3 set Use kde3.kile instead of kile etc. svn path=/nixpkgs/trunk/; revision=20910
2010-04-01 14:34:36 +01:00
inherit (kde3) arts kdelibs;
qt = qt3;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
kcachegrind = callPackage ../development/tools/misc/kcachegrind {
Move KDE 3 packages into kde3 set Use kde3.kile instead of kile etc. svn path=/nixpkgs/trunk/; revision=20910
2010-04-01 14:34:36 +01:00
inherit (kde3) kdelibs;
qt = qt3;
};
* Refactoring: move KDE and Gnome out of development/libraries into desktops. svn path=/nixpkgs/trunk/; revision=8105
2007-02-28 16:18:58 +00:00
};
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
Remove old kde packages svn path=/nixpkgs/trunk/; revision=21011
2010-04-11 16:50:41 +01:00
kde4 = kde44;
pkgs/applications/editors/emacs-modes/magit: updated to version magit-0.7-94-gbf42bf8 Magit has seen plenty of development since version 0.7, but for some reason there haven't been any new releases. This version bump updates the expression to build a current version of Magit directly from the Git repository. This change adds buildInputs 'autoconf' and 'automake'. These tools are required only because we aren't building from a proper release tarball. Once version 0.8 comes out, these dependencies can be dropped again. svn path=/nixpkgs/trunk/; revision=20650
2010-03-16 12:13:40 +00:00
Added my initial KDE 4.4 expression svn path=/nixpkgs/trunk/; revision=19906
2010-02-10 15:06:50 +00:00
kde44 = makeOverridable (import ../desktops/kde-4.4) (pkgs // {
Add qt-4.7.0-beta2 svn path=/nixpkgs/trunk/; revision=22830
2010-07-30 20:45:07 +01:00
qt4 = qt46;
Use stdenv2 in KDE to speed-up builds svn path=/nixpkgs/trunk/; revision=21611
2010-05-05 19:17:55 +01:00
stdenv = stdenv2;
Add parts of kdesupport for kde-4.5 svn path=/nixpkgs/trunk/; revision=22889
2010-08-02 18:11:19 +01:00
});
Add kdePackage function svn path=/nixpkgs/trunk/; revision=23008
2010-08-06 21:20:19 +01:00
kde45 = callPackage ../desktops/kde-4.5 {
callPackage = newScope ({
qt4 = qt47;
pyqt4 = pyqt4.override { qt4 = qt47; };
libdbusmenu_qt = libdbusmenu_qt.override { qt4 = qt47; };
shared_desktop_ontologies = shared_desktop_ontologies.override { v = "0.5"; };
stdenv = stdenv2;
} // kde45);
};
pkgs/applications/editors/emacs-modes/magit: updated to version magit-0.7-94-gbf42bf8 Magit has seen plenty of development since version 0.7, but for some reason there haven't been any new releases. This version bump updates the expression to build a current version of Magit directly from the Git repository. This change adds buildInputs 'autoconf' and 'automake'. These tools are required only because we aren't building from a proper release tarball. Once version 0.8 comes out, these dependencies can be dropped again. svn path=/nixpkgs/trunk/; revision=20650
2010-03-16 12:13:40 +00:00
Add Xfce Terminal emulator. Adds the terminal emulator, and the libraries that it depends upon. svn path=/nixpkgs/trunk/; revision=21820
2010-05-17 17:16:39 +01:00
xfce = xfce4;
pkgs/top-level/all-packages.nix: strip trailing whitenspace svn path=/nixpkgs/trunk/; revision=23118
2010-08-11 16:49:42 +01:00
* Add some more Xfce packages. svn path=/nixpkgs/trunk/; revision=23047
2010-08-08 23:43:00 +01:00
xfce4 = recurseIntoAttrs
(let callPackage = newScope pkgs.xfce4; in
import ../desktops/xfce-4 { inherit callPackage pkgs; });
Add Xfce Terminal emulator. Adds the terminal emulator, and the libraries that it depends upon. svn path=/nixpkgs/trunk/; revision=21820
2010-05-17 17:16:39 +01:00
pkgs/top-level/all-packages.nix: strip trailing whitenspace svn path=/nixpkgs/trunk/; revision=23118
2010-08-11 16:49:42 +01:00
Added XPlanet support to kdeedu-4.3.1, not that is an essential feature but it looks cool :-) svn path=/nixpkgs/trunk/; revision=17054
2009-09-11 15:06:51 +01:00
### SCIENCE
xlock: fixed build and updated to version 5.24 svn path=/nixpkgs/trunk/; revision=17356
2009-09-22 21:16:38 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
xplanet = callPackage ../applications/science/xplanet {
Added XPlanet support to kdeedu-4.3.1, not that is an essential feature but it looks cool :-) svn path=/nixpkgs/trunk/; revision=17054
2009-09-11 15:06:51 +01:00
inherit (gtkLibs) pango;
};
Added bash 4.0 (and readline 6.0, which is required by bash). svn path=/nixpkgs/trunk/; revision=14573
2009-03-17 14:03:03 +00:00
pkgs/top-level/all-packages.nix: strip trailing whitenspace svn path=/nixpkgs/trunk/; revision=23118
2010-08-11 16:49:42 +01:00
Add all my latest packages to all-packages.nix svn path=/nixpkgs/trunk/; revision=12957
2008-10-05 10:04:30 +01:00
### SCIENCE/GEOMETRY
Added toplevel clustalw2 svn path=/nixpkgs/trunk/; revision=11632
2008-04-15 10:35:52 +01:00
Added DrGeo svn path=/nixpkgs/trunk/; revision=12204
2008-06-27 20:15:01 +01:00
drgeo = builderDefsPackage (import ../applications/science/geometry/drgeo) {
inherit (gnome) libglade gtk;
inherit libxml2 guile perl intltool libtool pkgconfig;
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
};
Added DrGeo svn path=/nixpkgs/trunk/; revision=12204
2008-06-27 20:15:01 +01:00
Adding tetgen svn path=/nixpkgs/trunk/; revision=23138
2010-08-12 11:59:05 +01:00
tetgen = callPackage ../applications/science/geometry/tetgen { };
Updated CMake to version 2.6.3. svn path=/nixpkgs/trunk/; revision=15114
2009-04-17 14:48:22 +01:00
Add all my latest packages to all-packages.nix svn path=/nixpkgs/trunk/; revision=12957
2008-10-05 10:04:30 +01:00
### SCIENCE/BIOLOGY
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
alliance = callPackage ../applications/science/electronics/alliance {
Adding alliance 5.0 svn path=/nixpkgs/trunk/; revision=14008
2009-02-08 16:28:31 +00:00
motif = lesstif;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
arb = callPackage ../applications/science/biology/arb {
Added older version of lesstif for arb svn path=/nixpkgs/trunk/; revision=12974
2008-10-06 16:11:36 +01:00
lesstif = lesstif93;
Force gcc42 for arb (otherwise headers balk) svn path=/nixpkgs/trunk/; revision=18324
2009-11-10 17:16:06 +00:00
stdenv = overrideGCC stdenv gcc42;
Add all my latest packages to all-packages.nix svn path=/nixpkgs/trunk/; revision=12957
2008-10-05 10:04:30 +01:00
};
Introduced biolib package svn path=/nixpkgs/trunk/; revision=12535
2008-08-07 16:01:21 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
biolib = callPackage ../development/libraries/science/biology/biolib { };
Introduced biolib package svn path=/nixpkgs/trunk/; revision=12535
2008-08-07 16:01:21 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
emboss = callPackage ../applications/science/biology/emboss { };
Control for biology packages svn path=/nixpkgs/trunk/; revision=11994
2008-06-05 18:15:27 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
mrbayes = callPackage ../applications/science/biology/mrbayes { };
Control for biology packages svn path=/nixpkgs/trunk/; revision=11994
2008-06-05 18:15:27 +01:00
All-packages entry for NCBI C toolbox svn path=/nixpkgs/trunk/; revision=18925
2009-12-13 20:24:23 +00:00
ncbiCTools = builderDefsPackage ../development/libraries/ncbi {
inherit tcsh mesa lesstif;
pkgs/top-level/all-packages.nix: switch to Python 2.6 (except on Darwin) MacOS X can build Python 2.6 just fine, but for some reason a lot of modules don't work, so the resulting binary isn't very useful. svn path=/nixpkgs/branches/stdenv-updates/; revision=19598
2010-01-21 15:39:11 +00:00
inherit (xlibs) libX11 libXaw xproto libXt libSM libICE
All-packages entry for NCBI C toolbox svn path=/nixpkgs/trunk/; revision=18925
2009-12-13 20:24:23 +00: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 17:26:58 +01:00
ncbi_tools = callPackage ../applications/science/biology/ncbi-tools { };
Added ncbi-tools svn path=/nixpkgs/trunk/; revision=12003
2008-06-06 20:42:00 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
paml = callPackage ../applications/science/biology/paml { };
biology/paml added svn path=/nixpkgs/trunk/; revision=11997
2008-06-06 09:23:49 +01:00
Commenting out lapack/slr. Pjotr Prins, please add lapack gfortran.patch and uncomment. svn path=/nixpkgs/trunk/; revision=12963
2008-10-05 13:55:00 +01:00
/* slr = import ../applications/science/biology/slr {
Add all my latest packages to all-packages.nix svn path=/nixpkgs/trunk/; revision=12957
2008-10-05 10:04:30 +01:00
inherit fetchurl stdenv liblapack;
Commenting out lapack/slr. Pjotr Prins, please add lapack gfortran.patch and uncomment. svn path=/nixpkgs/trunk/; revision=12963
2008-10-05 13:55:00 +01:00
}; */
Add all my latest packages to all-packages.nix svn path=/nixpkgs/trunk/; revision=12957
2008-10-05 10:04:30 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pal2nal = callPackage ../applications/science/biology/pal2nal { };
Introduced pal2nal package svn path=/nixpkgs/trunk/; revision=12896
2008-09-19 14:39:17 +01:00
Updated CMake to version 2.6.3. svn path=/nixpkgs/trunk/; revision=15114
2009-04-17 14:48:22 +01:00
Add all my latest packages to all-packages.nix svn path=/nixpkgs/trunk/; revision=12957
2008-10-05 10:04:30 +01:00
### SCIENCE/MATH
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
atlas = callPackage ../development/libraries/science/math/atlas { };
Add all my latest packages to all-packages.nix svn path=/nixpkgs/trunk/; revision=12957
2008-10-05 10:04:30 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
blas = callPackage ../development/libraries/science/math/blas { };
pkgs/development/libraries/science/math/blas: added BLAS version 20070405 svn path=/nixpkgs/trunk/; revision=19671
2010-01-26 14:53:08 +00:00
changes for Content svn path=/nixpkgs/trunk/; revision=18928
2009-12-14 00:00:34 +00:00
content = builderDefsPackage ../applications/science/math/content {
inherit mesa lesstif;
pkgs/top-level/all-packages.nix: switch to Python 2.6 (except on Darwin) MacOS X can build Python 2.6 just fine, but for some reason a lot of modules don't work, so the resulting binary isn't very useful. svn path=/nixpkgs/branches/stdenv-updates/; revision=19598
2010-01-21 15:39:11 +00:00
inherit (xlibs) libX11 libXaw xproto libXt libSM libICE
adding libxcursor dependency svn path=/nixpkgs/trunk/; revision=18929
2009-12-14 00:14:43 +00:00
libXmu libXext libXcursor;
changes for Content svn path=/nixpkgs/trunk/; revision=18928
2009-12-14 00:00:34 +00:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
liblapack = callPackage ../development/libraries/science/math/liblapack { };
Add all my latest packages to all-packages.nix svn path=/nixpkgs/trunk/; revision=12957
2008-10-05 10:04:30 +01:00
Updated CMake to version 2.6.3. svn path=/nixpkgs/trunk/; revision=15114
2009-04-17 14:48:22 +01:00
Added a preliminary expression for Coq (no IDE support yet). svn path=/nixpkgs/trunk/; revision=11983
2008-06-04 16:10:05 +01:00
### SCIENCE/LOGIC
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
coq = callPackage ../applications/science/logic/coq {
Add expression for Coq 8.3 beta svn path=/nixpkgs/trunk/; revision=21734
2010-05-11 21:14:46 +01:00
camlp5 = camlp5_transitional;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
coq_beta = callPackage ../applications/science/logic/coq/beta.nix {
Updated Coq to version 8.2pl1 svn path=/nixpkgs/trunk/; revision=18069
2009-11-02 11:44:27 +00:00
camlp5 = camlp5_transitional;
Added a preliminary expression for Coq (no IDE support yet). svn path=/nixpkgs/trunk/; revision=11983
2008-06-04 16:10:05 +01:00
};
Added toplevel clustalw2 svn path=/nixpkgs/trunk/; revision=11632
2008-04-15 10:35:52 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
hol_light = callPackage ../applications/science/logic/hol_light { };
Add HOL Light and its dependencies. Add pkgs/applications/science/logic/hol_light and pkgs/applications/science/emacs-modes/hol_light Some functionalities of HOL Light requires the compiled sources of OCaml. For now we provide a new package ocaml_with_sources. After this shuold be merged with the current version of OCaml already present in nixpkgs. svn path=/nixpkgs/trunk/; revision=20008
2010-02-15 11:00:02 +00:00
Upgrade dmtcp to version 1.1.8 svn path=/nixpkgs/trunk/; revision=22933
2010-08-03 18:39:12 +01:00
hol_light_binaries = callPackage ../applications/science/logic/hol_light/binaries.nix { };
Add HOL Light and its dependencies. Add pkgs/applications/science/logic/hol_light and pkgs/applications/science/emacs-modes/hol_light Some functionalities of HOL Light requires the compiled sources of OCaml. For now we provide a new package ocaml_with_sources. After this shuold be merged with the current version of OCaml already present in nixpkgs. svn path=/nixpkgs/trunk/; revision=20008
2010-02-15 11:00:02 +00:00
# This is a special version of OCaml handcrafted especially for
# hol_light it should be merged with the current expresion for ocaml
# one day.
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ocaml_with_sources = callPackage ../applications/science/logic/hol_light/ocaml-with-sources.nix { };
Add HOL Light and its dependencies. Add pkgs/applications/science/logic/hol_light and pkgs/applications/science/emacs-modes/hol_light Some functionalities of HOL Light requires the compiled sources of OCaml. For now we provide a new package ocaml_with_sources. After this shuold be merged with the current version of OCaml already present in nixpkgs. svn path=/nixpkgs/trunk/; revision=20008
2010-02-15 11:00:02 +00:00
Add expression for Isabelle2009 svn path=/nixpkgs/trunk/; revision=18905
2009-12-11 17:00:52 +00:00
isabelle = import ../applications/science/logic/isabelle {
svn path=/nixpkgs/trunk/; revision=22880
2010-08-02 17:01:55 +01:00
inherit (pkgs) stdenv fetchurl nettools perl polyml;
inherit (pkgs.emacs23Packages) proofgeneral;
Add expression for Isabelle2009 svn path=/nixpkgs/trunk/; revision=18905
2009-12-11 17:00:52 +00:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
ssreflect = callPackage ../applications/science/logic/ssreflect {
Preliminary version of package ssreflect Add expression for ssreflect, an extension to the Coq Proof Assistant. Still has some clitches (see TODO in default.nix) but is usable anyway. svn path=/nixpkgs/trunk/; revision=18145
2009-11-05 15:08:12 +00:00
camlp5 = camlp5_transitional;
};
added ngspice svn path=/nixpkgs/trunk/; revision=12686
2008-08-21 21:43:53 +01:00
### SCIENCE / ELECTRONICS
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ngspice = callPackage ../applications/science/electronics/ngspice { };
added ngspice svn path=/nixpkgs/trunk/; revision=12686
2008-08-21 21:43:53 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
gtkwave = callPackage ../applications/science/electronics/gtkwave {
Adding gtkwave, to view waves generated by ghdl. svn path=/nixpkgs/trunk/; revision=19065
2009-12-21 10:35:50 +00:00
inherit (gtkLibs) gtk;
};
Updated CMake to version 2.6.3. svn path=/nixpkgs/trunk/; revision=15114
2009-04-17 14:48:22 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
xoscope = callPackage ../applications/science/electronics/xoscope {
Adding xoscope (oscilloscope for the sound card input, among others) svn path=/nixpkgs/trunk/; revision=22242
2010-06-13 11:01:16 +01:00
inherit (gtkLibs) gtk;
};
Add scilab-4.1.2 svn path=/nixpkgs/trunk/; revision=12810
2008-09-05 18:12:04 +01:00
### SCIENCE / MATH
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
maxima = callPackage ../applications/science/math/maxima { };
Move maxima close to scilab. (applications/science/math) Requested by Michael Raskin. svn path=/nixpkgs/trunk/; revision=12812
2008-09-05 18:21:45 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
wxmaxima = callPackage ../applications/science/math/wxmaxima { };
Added wxMaxima version 0.8.3. svn path=/nixpkgs/trunk/; revision=18015
2009-10-29 11:57:58 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
scilab = callPackage ../applications/science/math/scilab {
Add scilab-4.1.2 svn path=/nixpkgs/trunk/; revision=12810
2008-09-05 18:12:04 +01:00
inherit (gtkLibs) gtk;
withXaw3d = false;
withTk = true;
withGtk = false;
withOCaml = true;
withX = true;
};
Adding 'yacas', a CAS implemented in C++. svn path=/nixpkgs/trunk/; revision=23074
2010-08-09 22:58:21 +01:00
yacas = callPackage ../applications/science/math/yacas { };
Add Tulip, a graph visualization framework. svn path=/nixpkgs/trunk/; revision=22264
2010-06-14 19:30:35 +01:00
### SCIENCE / 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 17:26:58 +01:00
golly = callPackage ../applications/science/misc/golly { };
Adding golly (a cellular automata program) svn path=/nixpkgs/trunk/; revision=22391
2010-06-23 08:41:17 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
simgrid = callPackage ../applications/science/misc/simgrid {
Move SimGrid under `science/misc'. svn path=/nixpkgs/trunk/; revision=22312
2010-06-17 18:06:40 +01:00
stdenv = stdenv2;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
tulip = callPackage ../applications/science/misc/tulip {
Add Tulip, a graph visualization framework. svn path=/nixpkgs/trunk/; revision=22264
2010-06-14 19:30:35 +01:00
qt = qt4;
};
Updated CMake to version 2.6.3. svn path=/nixpkgs/trunk/; revision=15114
2009-04-17 14:48:22 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
vite = callPackage ../applications/science/misc/vite {
Add Visual Trace Explorer (ViTE). svn path=/nixpkgs/trunk/; revision=22311
2010-06-17 18:06:09 +01:00
qt = qt4;
stdenv = stdenv2;
};
* User-Mode Linux and GNU Patch. svn path=/nixpkgs/trunk/; revision=779
2004-02-13 14:42:28 +00: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 17:26:58 +01:00
atari800 = callPackage ../misc/emulators/atari800 { };
* Gnome: use GTK 2.4. svn path=/nixpkgs/trunk/; revision=1671
2004-11-03 21:28:03 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
ataripp = callPackage ../misc/emulators/atari++ { };
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
auctex = callPackage ../misc/tex/auctex { };
* Gnome: use GTK 2.4. svn path=/nixpkgs/trunk/; revision=1671
2004-11-03 21:28:03 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
busybox = callPackage ../misc/busybox {
Adding a busybox option to build it statically. Adding it to the cross builds. svn path=/nixpkgs/trunk/; revision=20516
2010-03-09 22:44:45 +00:00
enableStatic = true;
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cups = callPackage ../misc/cups { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gutenprint = callPackage ../misc/drivers/gutenprint { };
adding gutenprint (former gimp-print) and gutenprintBin. I still haven't found the source of the binary package containing the .ppd files Still impure but works. See comment. svn path=/nixpkgs/trunk/; revision=16881
2009-08-28 00:32:13 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gutenprintBin = callPackage ../misc/drivers/gutenprint/bin.nix { };
adding gutenprint (former gimp-print) and gutenprintBin. I still haven't found the source of the binary package containing the .ppd files Still impure but works. See comment. svn path=/nixpkgs/trunk/; revision=16881
2009-08-28 00:32:13 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
cupsBjnp = callPackage ../misc/cups/drivers/cups-bjnp { };
cups-bjnp driver svn path=/nixpkgs/trunk/; revision=16880
2009-08-28 00:32:10 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dblatex = callPackage ../misc/tex/dblatex { };
* Added dblatex, a DocBook -> PS/PDF/DVI converter. svn path=/nixpkgs/trunk/; revision=9569
2007-11-01 14:37:23 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dosbox = callPackage ../misc/emulators/dosbox { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
dpkg = callPackage ../tools/package-management/dpkg { };
added freestyle (non photorealistic renderer) and dependencies libQGLViewer, lib3ds svn path=/nixpkgs/trunk/; revision=12009
2008-06-08 04:56:32 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
electricsheep = callPackage ../misc/screensavers/electricsheep { };
* Electric Sheep, a screensaver. svn path=/nixpkgs/trunk/; revision=15415
2009-04-30 18:41:19 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
foldingathome = callPackage ../misc/foldingathome { };
Adding a folding-at-home client. svn path=/nixpkgs/trunk/; revision=15122
2009-04-17 21:36:54 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
freestyle = callPackage ../misc/freestyle {
added freestyle (non photorealistic renderer) and dependencies libQGLViewer, lib3ds svn path=/nixpkgs/trunk/; revision=12009
2008-06-08 04:56:32 +01:00
#stdenv = overrideGCC stdenv gcc41;
};
Added Gajim XMPP client in nearly full-feature configuration with all dependencies svn path=/nixpkgs/trunk/; revision=15001
2009-04-12 20:34:20 +01:00
gajim = builderDefsPackage (import ../applications/networking/instant-messengers/gajim) {
inherit perl intltool pyGtkGlade gettext pkgconfig makeWrapper pygobject
Updated CMake to version 2.6.3. svn path=/nixpkgs/trunk/; revision=15114
2009-04-17 14:48:22 +01:00
pyopenssl gtkspell libsexy pycrypto aspell pythonDBus pythonSexy
Added Gajim XMPP client in nearly full-feature configuration with all dependencies svn path=/nixpkgs/trunk/; revision=15001
2009-04-12 20:34:20 +01:00
docutils;
dbus = dbus.libs;
inherit (gnome) gtk libglade;
Updated CMake to version 2.6.3. svn path=/nixpkgs/trunk/; revision=15114
2009-04-17 14:48:22 +01:00
inherit (xlibs) libXScrnSaver libXt xproto libXext xextproto libX11
Added Gajim XMPP client in nearly full-feature configuration with all dependencies svn path=/nixpkgs/trunk/; revision=15001
2009-04-12 20:34:20 +01:00
scrnsaverproto;
python = pythonFull;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
generator = callPackage ../misc/emulators/generator {
* Updated SDL, NASM and Generator to the latest versions. * Moved Generator to the misc/emulators directory. svn path=/nixpkgs/trunk/; revision=4330
2005-12-03 01:33:18 +00:00
inherit (gtkLibs1x) gtk;
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
ghostscript = callPackage ../misc/ghostscript {
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
x11Support = false;
Use $NIXPKGS_CONFIG to determine whether ghostscript has cups support. svn path=/nixpkgs/trunk/; revision=14275
2009-02-27 13:44:31 +00:00
cupsSupport = getPkgConfig "ghostscript" "cups" true;
* Added Dosbox, a DOS (x86) emulator. svn path=/nixpkgs/trunk/; revision=4331
2005-12-03 02:32:02 +00:00
};
* MPlayer: updated to the SVN version. * VLC: updated to 0.9.8a. It now uses Qt for the GUI, which looks a lot better than the wxWidgets one. * libdvdread, libdvdnav: updated to 4.1.3. * ffmpeg: updated to 0.5 (a new release!). Got rid of the SVN version, which shouldn't be necessary anymore. svn path=/nixpkgs/trunk/; revision=14500
2009-03-10 21:03:51 +00:00
ghostscriptX = lowPrio (appendToName "with-X" (ghostscript.override {
* added gv (ghostscript-with-X is a dependency) svn path=/nixpkgs/trunk/; revision=9122
2007-08-14 15:09:58 +01:00
x11Support = true;
}));
added: dnsmasq, uisp, fltk libixp_for_wmii, acerhk kernel module, reiserfsprogs, radeontools, msmtp, procmail, pstree, gxemul changed: umlutilities to also support building tunctl optionally (needing kernel header files) wmii updated and wmiimenu added svn path=/nixpkgs/trunk/; revision=9242
2007-09-03 13:10:57 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
gxemul = callPackage ../misc/gxemul { };
jack added - compiles - haven't done any testing yet svn path=/nixpkgs/trunk/; revision=9403
2007-10-03 23:38:09 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
hplip = callPackage ../misc/drivers/hplip {
Adding hplip (HP's driver suite for printers and multi-function devices), which builds but I have not tried to do anything with it svn path=/nixpkgs/trunk/; revision=22321
2010-06-18 09:16:17 +01:00
qtSupport = true;
};
Uncommented mkDerivationByName. Now it doesn't break everything svn path=/nixpkgs/trunk/; revision=9415
2007-10-06 19:17:47 +01:00
# 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 17:26:58 +01:00
jackaudio = callPackage ../misc/jackaudio { };
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
keynav = callPackage ../tools/X11/keynav { };
Added gnuplotX - gnuplot with X11 on. svn path=/nixpkgs/trunk/; revision=9047
2007-08-04 16:12:14 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
lazylist = callPackage ../misc/tex/lazylist { };
* modified tetex to support extra .sty's from other packages * added lazylist and polytable (both tetex packages) * added lhs2tex ebuild, depending on the two above svn path=/nixpkgs/trunk/; revision=4609
2006-01-27 20:51:41 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
lilypond = callPackage ../misc/lilypond {
adding lilypond svn path=/nixpkgs/trunk/; revision=17028
2009-09-10 17:57:56 +01:00
inherit (gtkLibs) pango;
flex = flex2535;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
martyr = callPackage ../development/libraries/martyr { };
* Sorted the contents of all-packages.nix. svn path=/nixpkgs/trunk/; revision=6535
2006-09-15 16:28:53 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
maven = callPackage ../misc/maven/maven-1.0.nix { };
* Added GPL Ghostscript 8.15. svn path=/nixpkgs/trunk/; revision=2941
2005-04-29 14:23:15 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
maven2 = callPackage ../misc/maven { };
maven 2 binary (don't have time for source built right now) svn path=/nixpkgs/trunk/; revision=9953
2007-12-19 00:17:40 +00:00
* Added MESS, the Multi Emulator Super System. svn path=/nixpkgs/trunk/; revision=23126
2010-08-11 20:47:05 +01:00
mess = callPackage ../misc/emulators/mess { };
Make `nixUnstable' the default. svn path=/nixpkgs/trunk/; revision=21616
2010-05-05 20:48:32 +01:00
nix = nixUnstable;
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
nixStable = callPackage ../tools/package-management/nix {
pkgs/top-level/all-packages.nix: added support for overriding Nix's storeDir and stateDir in nix-pkgs.conf This patch allows Nix to be build using store locations other than "/nix". svn path=/nixpkgs/trunk/; revision=18206
2009-11-06 13:30:06 +00:00
storeDir = getPkgConfig "nix" "storeDir" "/nix/store";
stateDir = getPkgConfig "nix" "stateDir" "/nix/var";
* Use it. svn path=/nixpkgs/trunk/; revision=5248
2006-05-01 20:16:41 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
nixUnstable = callPackage ../tools/package-management/nix/unstable.nix {
Allow user config to override nix store paths, etc. Removed obsolete nixNoBDB. Use the following settings in ${NIXPKGS_CONFIG} to customize the installation of nixUnstable: nix = { OldDBSupport = false; storeDir = "/home/foobar/.nix/store"; stateDir = "/home/foobar/.nix/var"; } svn path=/nixpkgs/trunk/; revision=12909
2008-09-24 09:50:05 +01:00
storeDir = getPkgConfig "nix" "storeDir" "/nix/store";
* Change /nix/state back to /nix/var, this broke NixOS... svn path=/nixpkgs/trunk/; revision=12916
2008-09-24 18:38:40 +01:00
stateDir = getPkgConfig "nix" "stateDir" "/nix/var";
* Revive nixUnstable. svn path=/nixpkgs/trunk/; revision=7060
2006-11-17 12:49:46 +00:00
};
* Cleanup. svn path=/nixpkgs/trunk/; revision=6764
2006-10-18 15:04:55 +01:00
* Add a Nix expression for the Nix SQLite branch (temporarily). svn path=/nixpkgs/trunk/; revision=20377
2010-03-04 14:39:47 +00:00
# The SQLite branch.
* Mark nixSqlite as low priority to prevent it from being installed accidentally. svn path=/nixpkgs/trunk/; revision=20481
2010-03-09 08:45:20 +00:00
nixSqlite = lowPrio (makeOverridable (import ../tools/package-management/nix/sqlite.nix) {
* Updated Nix. svn path=/nixpkgs/trunk/; revision=21771
2010-05-14 09:57:16 +01:00
inherit fetchurl stdenv perl curl bzip2 openssl sqlite;
* Add a Nix expression for the Nix SQLite branch (temporarily). svn path=/nixpkgs/trunk/; revision=20377
2010-03-04 14:39:47 +00:00
storeDir = getPkgConfig "nix" "storeDir" "/nix/store";
stateDir = getPkgConfig "nix" "stateDir" "/nix/var";
* Mark nixSqlite as low priority to prevent it from being installed accidentally. svn path=/nixpkgs/trunk/; revision=20481
2010-03-09 08:45:20 +00:00
});
* Add a Nix expression for the Nix SQLite branch (temporarily). svn path=/nixpkgs/trunk/; revision=20377
2010-03-04 14:39:47 +00:00
all-packages.nix changes for previous commits svn path=/nixpkgs/trunk/; revision=11758
2008-05-06 08:03:41 +01:00
nixCustomFun = src: preConfigure: enableScripts: configureFlags:
* Use the latest Nix. What a relief. :-) svn path=/nixpkgs/trunk/; revision=10801
2008-02-21 13:44:06 +00:00
import ../tools/package-management/nix/custom.nix {
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
inherit fetchurl stdenv perl curl bzip2 openssl src preConfigure automake
* Updated libxml2 / libxslt. svn path=/nixpkgs/branches/xorg-7.5/; revision=18053
2009-10-30 12:42:48 +00:00
autoconf libtool configureFlags enableScripts lib bison libxml2;
* Use the latest Nix. What a relief. :-) svn path=/nixpkgs/trunk/; revision=10801
2008-02-21 13:44:06 +00:00
flex = flex2533;
Updating nix's aterm from aterm242fixes to aterm25 (proposed by niksnut). svn path=/nixpkgs/branches/stdenv-updates/; revision=18879
2009-12-10 14:50:50 +00:00
aterm = aterm25;
* Use the latest Nix. What a relief. :-) svn path=/nixpkgs/trunk/; revision=10801
2008-02-21 13:44:06 +00:00
db4 = db45;
Missed that Nix trunk uses fresher libxml2.. svn path=/nixpkgs/trunk/; revision=17275
2009-09-19 13:35:52 +01:00
inherit docbook5_xsl libxslt docbook5 docbook_xml_dtd_43 w3m;
* Use the latest Nix. What a relief. :-) svn path=/nixpkgs/trunk/; revision=10801
2008-02-21 13:44:06 +00:00
};
Added possibility to use non-default Nix. svn path=/nixpkgs/trunk/; revision=9663
2007-11-13 15:52:16 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
disnix = callPackage ../tools/package-management/disnix { };
xlock: fixed build and updated to version 5.24 svn path=/nixpkgs/trunk/; revision=17356
2009-09-22 21:16:38 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
disnix_activation_scripts = callPackage ../tools/package-management/disnix/activation-scripts { };
openssh: Let $NIXPKGS_CONFIG determine whether OpenSSH supports PAM or not. PAM is enabled by default, as before. To disable it, set openssh { pam = false; }; or simply pam = false; in ~/.nixpkgs/config.nix. svn path=/nixpkgs/trunk/; revision=12312
2008-07-08 00:11:13 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
DisnixService = callPackage ../tools/package-management/disnix/DisnixService { };
openssh: Let $NIXPKGS_CONFIG determine whether OpenSSH supports PAM or not. PAM is enabled by default, as before. To disable it, set openssh { pam = false; }; or simply pam = false; in ~/.nixpkgs/config.nix. svn path=/nixpkgs/trunk/; revision=12312
2008-07-08 00:11:13 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
latex2html = callPackage ../misc/tex/latex2html/default.nix {
applying patches provided by griswold svn path=/nixpkgs/trunk/; revision=19707
2010-01-27 12:12:35 +00:00
tex = tetex;
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pgadmin = callPackage ../applications/misc/pgadmin { };
pgadmin3 added svn path=/nixpkgs/trunk/; revision=10369
2008-01-29 01:24:54 +00:00
* PGF 2.00 (keeping the old one so that I can still build old documents). svn path=/nixpkgs/trunk/; revision=12999
2008-10-08 15:03:44 +01:00
pgf = pgf2;
# Keep the old PGF since some documents don't render properly with
# the new one.
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pgf1 = callPackage ../misc/tex/pgf/1.x.nix { };
* PGF 2.00 (keeping the old one so that I can still build old documents). svn path=/nixpkgs/trunk/; revision=12999
2008-10-08 15:03:44 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
pgf2 = callPackage ../misc/tex/pgf/2.x.nix { };
* Added pgf/tikz. * runLaTeX: allow additional TeX packages to be specified. * teTeX setup hook: TEXMFNIX doesn't seem to work, use TEXINPUTS. svn path=/nixpkgs/trunk/; revision=8261
2007-03-10 23:51:59 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
polytable = callPackage ../misc/tex/polytable { };
add cups svn path=/nixpkgs/trunk/; revision=4114
2005-10-21 14:06:43 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
psi = callPackage ../applications/networking/instant-messengers/psi {
Use updated QCA2 for psi svn path=/nixpkgs/trunk/; revision=22914
2010-08-03 08:39:56 +01:00
qca2 = kde45.qca2;
qca2_ossl = kde45.qca2_ossl;
Use the same qt4 for psi as for the used qca2 svn path=/nixpkgs/trunk/; revision=22918
2010-08-03 09:42:28 +01:00
qt4 = qt47;
* Removed selectVersion. There's no good reason to write `selectVersion ./foo "bar"' instead of `import ./foo/bar.nix'. * Replaced `with args' with formal function arguments in several packages. * Renamed several files to `default.nix'. As a general rule, version numbers should only be included in the filename when there is a reason to keep multiple versions of a package in Nixpkgs. Otherwise, it just makes it harder to update the package. svn path=/nixpkgs/trunk/; revision=18403
2009-11-18 09:39:59 +00:00
};
all-packages.nix changes for previous commits svn path=/nixpkgs/trunk/; revision=11217
2008-03-20 09:52:40 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
putty = callPackage ../applications/networking/remote/putty {
Updating putty to the last svn version, so now it can work with gtk2. The previous wanted gtk1, that did not build on x86_64-linux svn path=/nixpkgs/trunk/; revision=21649
2010-05-07 15:18:00 +01:00
inherit (gtkLibs) gtk;
nixpkgs dir: nvidia and libsrvg svn path=/nixpkgs/trunk/; revision=8785
2007-05-28 15:10:46 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
rssglx = callPackage ../misc/screensavers/rss-glx { };
* add busybox * uclibc needs mktemp svn path=/nixpkgs/trunk/; revision=4969
2006-03-02 18:17:45 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
xlockmore = callPackage ../misc/screensavers/xlockmore {
xlock: fixed build and updated to version 5.24 svn path=/nixpkgs/trunk/; revision=17356
2009-09-22 21:16:38 +01:00
pam = if getPkgConfig "xlockmore" "pam" true then pam else null;
Add XLockmore, a screen locker for X11. Currently, password authentication doesn't work. svn path=/nixpkgs/trunk/; revision=10701
2008-02-15 10:40:20 +00:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
saneBackends = callPackage ../misc/sane-backends {
* Clean up indentation (expanded tabs etc.). svn path=/nixpkgs/trunk/; revision=11150
2008-03-17 09:41:28 +00:00
gt68xxFirmware = getConfig ["sane" "gt68xxFirmware"] null;
Various.. Added ircd-hybrid. Added USB support in SANE. Added Xsane. Added gt68xx firmware support. svn path=/nixpkgs/trunk/; revision=9070
2007-08-08 21:33:36 +01:00
};
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
saneFrontends = callPackage ../misc/sane-front {
Various.. Added ircd-hybrid. Added USB support in SANE. Added Xsane. Added gt68xx firmware support. svn path=/nixpkgs/trunk/; revision=9070
2007-08-08 21:33:36 +01:00
inherit (gtkLibs) gtk;
add libpcap, ethereal, sane-backends svn path=/nixpkgs/trunk/; revision=4213
2005-11-03 20:00:43 +00:00
};
put all source with tags stuff into its own file, now appends tag files to TAG_FILES env var using nix-support updated myEnvFun svn path=/nixpkgs/trunk/; revision=12097
2008-06-15 12:54:22 +01:00
sourceAndTags = import ../misc/source-and-tags {
moved hasktags to ghc68executables, updated url to new location svn path=/nixpkgs/trunk/; revision=12680
2008-08-21 12:07:44 +01:00
inherit pkgs stdenv unzip lib ctags;
doh svn path=/nixpkgs/trunk/; revision=16292
2009-07-09 23:23:51 +01:00
hasktags = haskellPackages.myhasktags;
put all source with tags stuff into its own file, now appends tag files to TAG_FILES env var using nix-support updated myEnvFun svn path=/nixpkgs/trunk/; revision=12097
2008-06-15 12:54:22 +01:00
};
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
splix = callPackage ../misc/cups/drivers/splix { };
Add splix cups driver svn path=/nixpkgs/trunk/; revision=21078
2010-04-14 20:27:15 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
tetex = callPackage ../misc/tex/tetex { };
add linuxwacom. Now, this is still without the driver for X (even though I don't know how that has to be used in X) svn path=/nixpkgs/trunk/; revision=4640
2006-01-31 15:18:27 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
tex4ht = callPackage ../misc/tex/tex4ht { };
Add tex4ht. svn path=/nixpkgs/trunk/; revision=19739
2010-01-31 12:13:33 +00:00
svn path=/nixpkgs/trunk/; revision=22959
2010-08-05 11:42:05 +01:00
texFunctions = import ../misc/tex/nix pkgs;
* Added rss-glx, a collection of nice OpenGL screensavers. svn path=/nixpkgs/trunk/; revision=4614
2006-01-28 02:10:26 +00:00
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
texLive = builderDefsPackage (import ../misc/tex/texlive) {
all-packages.nix changes for previous commits svn path=/nixpkgs/trunk/; revision=11217
2008-03-20 09:52:40 +00:00
inherit builderDefs zlib bzip2 ncurses libpng ed
I added extra dependencies to TeXLive - just in case. svn path=/nixpkgs/trunk/; revision=12323
2008-07-08 19:23:15 +01:00
gd t1lib freetype icu perl ruby expat curl
TeXLive needs fontconfig svn path=/nixpkgs/trunk/; revision=19916
2010-02-10 20:43:59 +00:00
libjpeg bison python fontconfig;
all-packages.nix changes for previous commits svn path=/nixpkgs/trunk/; revision=11217
2008-03-20 09:52:40 +00:00
inherit (xlibs) libXaw libX11 xproto libXt libXpm
Minor fix of "inherit"s. svn path=/nixpkgs/trunk/; revision=12708
2008-08-25 15:52:53 +01:00
libXmu libXext xextproto libSM libICE;
all-packages.nix changes for previous commits svn path=/nixpkgs/trunk/; revision=11217
2008-03-20 09:52:40 +00:00
flex = flex2535;
ghostscript = ghostscriptX;
};
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
/* Look in configurations/misc/raskin.nix for usage example (around revisions
where TeXLive was added)
TeXLive. Now more configurable, and more options included. Beamer class for conference slides added. Before asking questions, look in configurations/misc/raskin.nix or in all-packages.nix . svn path=/nixpkgs/trunk/; revision=11257
2008-03-22 13:04:04 +00:00
(texLiveAggregationFun {
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
paths = [texLive texLiveExtra texLiveCMSuper
TeXLive. Now more configurable, and more options included. Beamer class for conference slides added. Before asking questions, look in configurations/misc/raskin.nix or in all-packages.nix . svn path=/nixpkgs/trunk/; revision=11257
2008-03-22 13:04:04 +00:00
texLiveBeamer
];
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
})
Some more details about texLiveAggregation in comment svn path=/nixpkgs/trunk/; revision=11832
2008-05-16 05:52:47 +01:00
You need to use texLiveAggregationFun to regenerate, say, ls-R (TeX-related file list)
Just installing a few packages doesn't work.
TeXLive. Now more configurable, and more options included. Beamer class for conference slides added. Before asking questions, look in configurations/misc/raskin.nix or in all-packages.nix . svn path=/nixpkgs/trunk/; revision=11257
2008-03-22 13:04:04 +00:00
*/
bison: use version 2.3 by default (the latest) svn path=/nixpkgs/trunk/; revision=12703
2008-08-25 14:25:07 +01:00
texLiveAggregationFun =
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
(builderDefsPackage (import ../misc/tex/texlive/aggregate.nix));
TeXLive. Now more configurable, and more options included. Beamer class for conference slides added. Before asking questions, look in configurations/misc/raskin.nix or in all-packages.nix . svn path=/nixpkgs/trunk/; revision=11257
2008-03-22 13:04:04 +00:00
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
texLiveContext = builderDefsPackage (import ../misc/tex/texlive/context.nix) {
Added font building support to builder-defs; made realCurl configurable; added Linux Libertine font; added ConTEXt svn path=/nixpkgs/trunk/; revision=11739
2008-04-28 11:10:44 +01:00
inherit texLive;
};
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
texLiveExtra = builderDefsPackage (import ../misc/tex/texlive/extra.nix) {
TeXLive. Now more configurable, and more options included. Beamer class for conference slides added. Before asking questions, look in configurations/misc/raskin.nix or in all-packages.nix . svn path=/nixpkgs/trunk/; revision=11257
2008-03-22 13:04:04 +00:00
inherit texLive;
};
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
texLiveCMSuper = builderDefsPackage (import ../misc/tex/texlive/cm-super.nix) {
TeXLive. Now more configurable, and more options included. Beamer class for conference slides added. Before asking questions, look in configurations/misc/raskin.nix or in all-packages.nix . svn path=/nixpkgs/trunk/; revision=11257
2008-03-22 13:04:04 +00:00
inherit texLive;
};
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
texLiveLatexXColor = builderDefsPackage (import ../misc/tex/texlive/xcolor.nix) {
TeXLive. Now more configurable, and more options included. Beamer class for conference slides added. Before asking questions, look in configurations/misc/raskin.nix or in all-packages.nix . svn path=/nixpkgs/trunk/; revision=11257
2008-03-22 13:04:04 +00:00
inherit texLive;
};
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
texLivePGF = builderDefsPackage (import ../misc/tex/texlive/pgf.nix) {
TeXLive. Now more configurable, and more options included. Beamer class for conference slides added. Before asking questions, look in configurations/misc/raskin.nix or in all-packages.nix . svn path=/nixpkgs/trunk/; revision=11257
2008-03-22 13:04:04 +00:00
inherit texLiveLatexXColor texLive;
};
Big breaking change. I have radically reduced number of nulls used in all-packages.nix and generally switched to composedArgsAndFun which simply adds .meta.function to everything that has come through it.. I have not tested the build, because OO.o has to be updated... svn path=/nixpkgs/trunk/; revision=12625
2008-08-14 23:04:30 +01:00
texLiveBeamer = builderDefsPackage (import ../misc/tex/texlive/beamer.nix) {
TeXLive. Now more configurable, and more options included. Beamer class for conference slides added. Before asking questions, look in configurations/misc/raskin.nix or in all-packages.nix . svn path=/nixpkgs/trunk/; revision=11257
2008-03-22 13:04:04 +00:00
inherit texLiveLatexXColor texLivePGF texLive;
};
all-packages.nix changes for previous commits svn path=/nixpkgs/trunk/; revision=11217
2008-03-20 09:52:40 +00:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
toolbuslib = callPackage ../development/libraries/toolbuslib { };
added entries for libtoolbus, toolbus, and joe svn path=/nixpkgs/trunk/; revision=4680
2006-02-02 16:31:23 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
trac = callPackage ../misc/trac {
Fix typo from previous commit. svn path=/nixpkgs/trunk/; revision=16230
2009-07-07 23:34:03 +01:00
inherit (pythonPackages) pysqlite;
Trying to reinstate the meta-based Hydra builds svn path=/nixpkgs/trunk/; revision=16883
2009-08-28 07:29:21 +01:00
};
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
vice = callPackage ../misc/emulators/vice {
* Added the Dutch Tax Return program for 2009. svn path=/nixpkgs/trunk/; revision=20828
2010-03-25 19:40:19 +00:00
inherit (gtkLibs) gtk;
};
all-packages.nix: add adns library This commit also adds the combinator 'getPkgConfig', which ADNS uses to let the user enable/disable static linking of the library. The behavior of the adns expression can be customized in ~/.nixpkgs/config.nix by setting, i.e., "adns = { version = "1.4"; static = true; };". svn path=/nixpkgs/trunk/; revision=12155
2008-06-18 23:48:34 +01:00
* Use callPackage_i686 for i686-only packages. svn path=/nixpkgs/trunk/; revision=23113
2010-08-11 14:25:30 +01:00
# Wine cannot be built in 64-bit; use a 32-bit build instead.
wine = callPackage_i686 ../misc/emulators/wine {
flex = pkgsi686Linux.flex2535;
};
Added xmove - proxy X server which can move its clients to another one. Useful with Xvfb - so you can save your X session during needed reload of X. svn path=/nixpkgs/trunk/; revision=8917
2007-06-25 22:46:18 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
x2x = callPackage ../tools/X11/x2x { };
Adding x2x. Patch by Oleksandr Kozachuk svn path=/nixpkgs/trunk/; revision=21796
2010-05-16 17:23:17 +01:00
* Use callPackage for most packages in all-packages.nix. `callPackage' was described here: http://www.mail-archive.com/nix-dev@cs.uu.nl/msg02624.html It allows all-packages.nix to be shortened significantly (from 10152 to 6980 lines) by automatically filling in package functions' required arguments from `pkgs'. That is, a function { stdenv, fetchurl, libfoo, libbar }: ... can now be called as callPackage ./<bla>.nix { }; rather than import ./<bla>.nix { inherit stdenv fetchurl libfoo libbar; }; This reduces boring typing work when adding a dependency and reduces the number of trivial commits to all-packages.nix. Overrides or arguments that don't exist in `pkgs' can be passed explicitly, e.g., callPackage ./<bla>.nix { libfoo = libfoo_1_2_3; }; The conversion was done automatically with a magic Perl regexp. I checked that `nix-env' produces the same results before and after (except for three packages that depend on webkit, which uses deepOverride). `callPackage' applies `makeOverridable' automatically, so almost every package now exports an `override' function. There are two downsides to using callPackage: - Evaluation is a bit slower (about 15% on `nix-env -qa --drv-path \*'). - There can be unexpected results for functions that have default argument values. For instance, a function { libfoo ? null }: ... called using `callPackage' will be passed a `libfoo' argument provided that `pkgs.libfoo' exists. If this is used to control whether a package has to have a certain dependency, you need to explicitly write: callPackage ./<bla>.nix { libfoo = null; }; svn path=/nixpkgs/trunk/; revision=22885
2010-08-02 17:26:58 +01:00
xosd = callPackage ../misc/xosd { };
added xosd svn path=/nixpkgs/trunk/; revision=11340
2008-03-29 00:49:26 +00:00
all-packages: remove trailing spaces svn path=/nixpkgs/trunk/; revision=22907
2010-08-02 22:40:34 +01:00
xsane = callPackage ../misc/xsane {
Various.. Added ircd-hybrid. Added USB support in SANE. Added Xsane. Added gt68xx firmware support. svn path=/nixpkgs/trunk/; revision=9070
2007-08-08 21:33:36 +01:00
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 17:26:58 +01:00
yafc = callPackage ../applications/networking/yafc { };
Adding yafc-1.1.1 svn path=/nixpkgs/trunk/; revision=13846
2009-01-25 14:31:51 +00:00
update my_env. Hopefully does a better job now svn path=/nixpkgs/trunk/; revision=13037
2008-10-09 23:57:20 +01:00
myEnvFun = import ../misc/my-env {
inherit substituteAll pkgs;
inherit (stdenv) mkDerivation;
};
put all source with tags stuff into its own file, now appends tag files to TAG_FILES env var using nix-support updated myEnvFun svn path=/nixpkgs/trunk/; revision=12097
2008-06-15 12:54:22 +01:00
adding cdtEnv symlinking deps into one $out/cdt-env/{lib,include} directory and collection which let's you install and update a set of derivations at once svn path=/nixpkgs/trunk/; revision=16224
2009-07-07 21:53:16 +01:00
misc = import ../misc/misc.nix { inherit pkgs stdenv; };
Updated CMake to version 2.6.3. svn path=/nixpkgs/trunk/; revision=15114
2009-04-17 14:48:22 +01:00
* buildRPM: print out the RPMs in the image. svn path=/nixpkgs/trunk/; revision=11168
2008-03-17 17:29:07 +00:00
}; in pkgs
Copy permalink