nixpkgs/pkgs/top-level/default.nix

126 lines
4.6 KiB
Nix
Raw Normal View History

/* This function composes the Nix Packages collection. It:
1. Applies the final stage to the given `config` if it is a function
2. Infers an appropriate `platform` based on the `system` if none is
provided
3. Defaults to no non-standard config and no cross-compilation target
4. Uses the above to infer the default standard environment's (stdenv's)
stages if no stdenv's are provided
5. Folds the stages to yield the final fully booted package set for the
chosen stdenv
Use `impure.nix` to also infer the `system` based on the one on which
evaluation is taking place, and the configuration from environment variables
or dot-files. */
{ # The system packages will be built on. See the manual for the
# subtle division of labor between these two `*System`s and the three
# `*Platform`s.
localSystem
, # The system packages will ultimately be run on.
crossSystem ? localSystem
, # Allow a configuration attribute set to be passed in as an argument.
config ? {}
, # List of overlays layers used to extend Nixpkgs.
overlays ? []
, # List of overlays to apply to target packages only.
crossOverlays ? []
, # A function booting the final package set for a specific standard
# environment. See below for the arguments given to that function, the type of
# list it returns.
stdenvStages ? import ../stdenv
} @ args:
let # Rename the function arguments
config0 = config;
crossSystem0 = crossSystem;
in let
lib = import ../../lib;
# Allow both:
# { /* the config */ } and
# { pkgs, ... } : { /* the config */ }
config1 =
if lib.isFunction config0
then config0 { inherit pkgs; }
else config0;
# From a minimum of `system` or `config` (actually a target triple, *not*
# nixpkgs configuration), infer the other one and platform as needed.
localSystem = lib.systems.elaborate (
# Allow setting the platform in the config file. This take precedence over
2017-04-19 18:27:24 +00:00
# the inferred platform, but not over an explicitly passed-in one.
builtins.intersectAttrs { platform = null; } config1
// args.localSystem);
crossSystem = if crossSystem0 == null then localSystem
else lib.systems.elaborate crossSystem0;
configEval = lib.evalModules {
modules = [
./config.nix
({ options, ... }: {
_file = "nixpkgs.config";
# filter-out known options, FIXME: remove this eventually
config = builtins.intersectAttrs options config1;
})
];
};
# take all the rest as-is
config = lib.showWarnings configEval.config.warnings
(config1 // builtins.removeAttrs configEval.config [ "_module" ]);
# A few packages make a new package set to draw their dependencies from.
# (Currently to get a cross tool chain, or forced-i686 package.) Rather than
# give `all-packages.nix` all the arguments to this function, even ones that
# don't concern it, we give it this function to "re-call" nixpkgs, inheriting
# whatever arguments it doesn't explicitly provide. This way,
# `all-packages.nix` doesn't know more than it needs too.
#
2019-02-03 15:30:13 +00:00
# It's OK that `args` doesn't include default arguments from this file:
# they'll be deterministically inferred. In fact we must *not* include them,
# because it's important that if some parameter which affects the default is
# substituted with a different argument, the default is re-inferred.
#
# To put this in concrete terms, this function is basically just used today to
# use package for a different platform for the current platform (namely cross
# compiling toolchains and 32-bit packages on x86_64). In both those cases we
# want the provided non-native `localSystem` argument to affect the stdenv
# chosen.
#
# NB!!! This thing gets its `config` argument from `args`, i.e. it's actually
# `config0`. It is important to keep it to `config0` format (as opposed to the
# result of `evalModules`, i.e. the `config` variable above) throughout all
# nixpkgs evaluations since the above function `config0 -> config` implemented
# via `evalModules` is not idempotent. In other words, if you add `config` to
# `newArgs`, expect strange very hard to debug errors! (Yes, I'm speaking from
# experience here.)
nixpkgsFun = newArgs: import ./. (args // newArgs);
# Partially apply some arguments for building bootstraping stage pkgs
# sets. Only apply arguments which no stdenv would want to override.
allPackages = newArgs: import ./stage.nix ({
inherit lib nixpkgsFun;
} // newArgs);
boot = import ../stdenv/booter.nix { inherit lib allPackages; };
stages = stdenvStages {
inherit lib localSystem crossSystem config overlays crossOverlays;
};
pkgs = boot stages;
in pkgs