nixpkgs-suyu/pkgs/top-level/default.nix

/* 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.
  stdenvFunc ? import ../stdenv

, 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 = stdenvFunc {
    inherit lib allPackages system platform crossSystem config;
  };

  pkgs = allPackages { inherit system stdenv config crossSystem platform; };

in pkgs