/* 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 (stdenv) if none is provided 5. Builds the final stage --- a fully booted package set with 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 (e.g., `i686-linux') for which to build the packages. system , # Allow a configuration attribute set to be passed in as an argument. config ? {} , # The standard environment for building packages, or rather a function # providing it. See below for the arguments given to that function. stdenv ? assert false; null , crossSystem ? null , platform ? assert false; null } @ args: let # Rename the function arguments configExpr = config; in let lib = import ../../lib; # Allow both: # { /* the config */ } and # { pkgs, ... } : { /* the config */ } config = if builtins.isFunction configExpr then configExpr { inherit pkgs; } else configExpr; # Allow setting the platform in the config file. Otherwise, let's use a # reasonable default. platform = args.platform or (config.platform or (import ./platforms.nix).selectPlatformBySystem system); # 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. # # It's OK that `args` doesn't include default arguemtns 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 `system` argument to affect the stdenv chosen. 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); stdenv = (args.stdenv or (import ../stdenv)) { inherit lib allPackages system platform crossSystem config; }; pkgs = allPackages { inherit system stdenv config crossSystem platform; }; in pkgs