core/pkgs/build-support/packages.nix

{ ... }:
res: pkgs: super:

with pkgs; {
  autoreconfHook = callPackage (
    {
      makeSetupHook,
      autoconf,
      automake,
      gettext,
      libtool,
    }:
    makeSetupHook {
      name = "autoreconf-hook";
      propagatedBuildInputs = [
        autoconf
        automake
        gettext
        libtool
      ];
    } ./setup-hooks/autoreconf.sh
  ) { };

  autoreconfHook264 = autoreconfHook.override {
    autoconf = autoconf264;
    automake = automake111x;
  };

  autoreconfHook269 = autoreconfHook.override { autoconf = autoconf269; };
  autoreconfHook271 = autoreconfHook.override { autoconf = autoconf271; };

  autoPatchelfHook = makeSetupHook {
    name = "auto-patchelf-hook";
    propagatedBuildInputs = [ bintools ];
    substitutions = {
      pythonInterpreter = "${python3.withPackages (ps: [ ps.pyelftools ])}/bin/python";
      autoPatchelfScript = ./setup-hooks/auto-patchelf.py;
    };
    meta.platforms = lib.platforms.linux;
  } ./setup-hooks/auto-patchelf.sh;

  # tomato-c = callPackage ../applications/misc/tomato-c { };

  # appflowy = callPackage ../applications/office/appflowy { };

  # appimageTools = callPackage ./appimage { };

  # appindicator-sharp = callPackage ../development/libraries/appindicator-sharp { };

  # bindle = callPackage ../servers/bindle {
  #   inherit (darwin.apple_sdk.frameworks) Security;
  # };

  stripJavaArchivesHook = makeSetupHook {
    name = "strip-java-archives-hook";
    propagatedBuildInputs = [ strip-nondeterminism ];
  } ./setup-hooks/strip-java-archives.sh;

  ensureNewerSourcesHook =
    { year }:
    makeSetupHook { name = "ensure-newer-sources-hook"; } (
      writeScript "ensure-newer-sources-hook.sh" ''
        postUnpackHooks+=(_ensureNewerSources)
        _ensureNewerSources() {
          '${findutils}/bin/find' "$sourceRoot" \
            '!' -newermt '${year}-01-01' -exec touch -h -d '${year}-01-02' '{}' '+'
        }
      ''
    );

  # Zip file format only allows times after year 1980, which makes e.g. Python
  # wheel building fail with:
  # ValueError: ZIP does not support timestamps before 1980
  ensureNewerSourcesForZipFilesHook = ensureNewerSourcesHook { year = "1980"; };

  # addDriverRunpath is the preferred package name, as this enables
  # many more scenarios than just opengl now.
  addDriverRunpath = callPackage ./add-driver-runpath { };

  # addOpenGLRunpath should be added to aliases.nix after the 24.05 branch-off.
  # Post 24.11 branch-off, this should throw an error in aliases.nix.
  addOpenGLRunpath = callPackage ./add-opengl-runpath { };

  updateAutotoolsGnuConfigScriptsHook = makeSetupHook {
    name = "update-autotools-gnu-config-scripts-hook";
    substitutions = {
      gnu_config = gnu-config;
    };
  } ./setup-hooks/update-autotools-gnu-config-scripts.sh;

  # gogUnpackHook = makeSetupHook
  #   {
  #     name = "gog-unpack-hook";
  #     propagatedBuildInputs = [ innoextract file-rename ];
  #   }
  #   ./setup-hooks/gog-unpack.sh;

  buildEnv = callPackage ./buildenv { }; # not actually a package

  buildFHSEnv = buildFHSEnvBubblewrap;
  buildFHSEnvChroot = callPackage ./build-fhsenv-chroot { }; # Deprecated; use buildFHSEnv/buildFHSEnvBubblewrap
  buildFHSEnvBubblewrap = callPackage ./build-fhsenv-bubblewrap { };

  # buildMaven = callPackage ./build-maven.nix { };

  checkpointBuildTools = callPackage ./checkpoint-build.nix { };

  dhallDirectoryToNix = callPackage ./dhall/directory-to-nix.nix { };

  dhallPackageToNix = callPackage ./dhall/package-to-nix.nix { };

  dhallToNix = callPackage ./dhall/to-nix.nix { };

  expand-response-params = callPackage ./expand-response-params { };

  diffPlugins = (callPackage ./plugins.nix { }).diffPlugins;

  dieHook = makeSetupHook { name = "die-hook"; } ./setup-hooks/die.sh;

  # dockerTools = callPackage ./docker
  #   {
  #     writePython3 = buildPackages.writers.writePython3;
  #   } // { __attrsFailEvaluation = true; };

  fakeNss = callPackage ./fake-nss { };

  tarsum = callPackage ./docker/tarsum.nix { };

  # nix-prefetch-docker = callPackage ./docker/nix-prefetch-docker.nix { };

  # buildDotnetModule = callPackage ./dotnet/build-dotnet-module { };
  # nuget-to-nix = callPackage ./dotnet/nuget-to-nix { };
  # mkNugetSource = callPackage ./dotnet/make-nuget-source { };
  # mkNugetDeps = callPackage ./dotnet/make-nuget-deps { };

  # buildDotnetGlobalTool = callPackage ./dotnet/build-dotnet-global-tool { };

  # dotnetenv = callPackage ./dotnet/dotnetenv {
  #   dotnetfx = dotnetfx40;
  # };

  # buildDotnetPackage = callPackage ./dotnet/build-dotnet-package { };
  # fetchNuGet = callPackage ./dotnet/fetchnuget { };
  # dotnetbuildhelpers = callPackage ./dotnet/dotnetbuildhelpers { };

  # fetchbower = callPackage ./fetchbower {
  #   inherit (nodePackages) bower2nix;
  # };

  # fetchbzr = callPackage ./fetchbzr { };

  fetchcvs =
    if
      stdenv.buildPlatform != stdenv.hostPlatform
    # hack around splicing being crummy with things that (correctly) don't eval.
    then
      buildPackages.fetchcvs
    else
      callPackage ./fetchcvs { };

  fetchdarcs = callPackage ./fetchdarcs { };

  fetchdocker = callPackage ./fetchdocker { };

  fetchDockerConfig = callPackage ./fetchdocker/fetchDockerConfig.nix { };

  fetchDockerLayer = callPackage ./fetchdocker/fetchDockerLayer.nix { };

  fetchfossil = callPackage ./fetchfossil { };

  fetchgit =
    (callPackage ./fetchgit {
      git = buildPackages.gitMinimal;
      cacert = buildPackages.cacert;
      git-lfs = buildPackages.git-lfs;
    })
    // {
      # fetchgit is a function, so we use // instead of passthru.
      tests = pkgs.tests.fetchgit;
    };

  fetchgitLocal = callPackage ./fetchgitlocal { };

  fetchmtn = callPackage ./fetchmtn (config.fetchmtn or { });

  fetchMavenArtifact = callPackage ./fetchmavenartifact { };

  fetchpijul = callPackage ./fetchpijul { };

  inherit (callPackages ./node/fetch-yarn-deps { }) fixup-yarn-lock prefetch-yarn-deps fetchYarnDeps;

  prefer-remote-fetch = import ./prefer-remote-fetch;

  fetchpatch =
    callPackage ./fetchpatch {
      # 0.3.4 would change hashes: https://github.com/NixOS/nixpkgs/issues/25154
      patchutils = buildPackages.patchutils_0_3_3;
    }
    // {
      tests = pkgs.tests.fetchpatch;
      version = 1;
    };

  fetchpatch2 = callPackage ./fetchpatch { patchutils = buildPackages.patchutils_0_4_2; } // {
    tests = pkgs.tests.fetchpatch2;
    version = 2;
  };

  fetchs3 = callPackage ./fetchs3 { };

  fetchtorrent = callPackage ./fetchtorrent { };

  fetchsvn =
    if
      stdenv.buildPlatform != stdenv.hostPlatform
    # hack around splicing being crummy with things that (correctly) don't eval.
    then
      buildPackages.fetchsvn
    else
      callPackage ./fetchsvn { };

  fetchsvnrevision = import ./fetchsvnrevision runCommand subversion;

  fetchsvnssh = callPackage ./fetchsvnssh { };

  fetchhg = callPackage ./fetchhg { };

  fetchFirefoxAddon = callPackage ./fetchfirefoxaddon { } // {
    tests = pkgs.tests.fetchFirefoxAddon;
  };

  fetchNextcloudApp = callPackage ./fetchnextcloudapp { };

  # `fetchurl' downloads a file from the network.
  fetchurl =
    if stdenv.buildPlatform != stdenv.hostPlatform then
      buildPackages.fetchurl # No need to do special overrides twice,
    else
      makeOverridable (import ./fetchurl) {
        inherit lib stdenvNoCC buildPackages;
        inherit cacert;
        curl = buildPackages.curlMinimal.override (old: rec {
          # break dependency cycles
          fetchurl = stdenv.fetchurlBoot;
          zlib = buildPackages.zlib.override { fetchurl = stdenv.fetchurlBoot; };
          pkg-config = buildPackages.pkg-config.override (old: {
            pkg-config = old.pkg-config.override { fetchurl = stdenv.fetchurlBoot; };
          });
          perl = buildPackages.perl.override { fetchurl = stdenv.fetchurlBoot; };
          openssl = buildPackages.openssl.override {
            fetchurl = stdenv.fetchurlBoot;
            buildPackages = {
              coreutils = buildPackages.coreutils.override {
                fetchurl = stdenv.fetchurlBoot;
                inherit perl;
                xz = buildPackages.xz.override { fetchurl = stdenv.fetchurlBoot; };
                gmp = null;
                aclSupport = false;
                attrSupport = false;
              };
              inherit perl;
            };
            inherit perl;
          };
          libssh2 = buildPackages.libssh2.override {
            fetchurl = stdenv.fetchurlBoot;
            inherit zlib openssl;
          };
          # On darwin, libkrb5 needs bootstrap_cmds which would require
          # converting many packages to fetchurl_boot to avoid evaluation cycles.
          # So turn gssSupport off there, and on Windows.
          # On other platforms, keep the previous value.
          gssSupport =
            if stdenv.isDarwin || stdenv.hostPlatform.isWindows then false else old.gssSupport or true; # `? true` is the default
          libkrb5 = buildPackages.libkrb5.override {
            fetchurl = stdenv.fetchurlBoot;
            inherit pkg-config perl openssl;
            keyutils = buildPackages.keyutils.override { fetchurl = stdenv.fetchurlBoot; };
          };
          nghttp2 = buildPackages.nghttp2.override {
            fetchurl = stdenv.fetchurlBoot;
            inherit pkg-config;
            enableApp = false; # curl just needs libnghttp2
            enableTests = false; # avoids bringing `cunit` and `tzdata` into scope
          };
        });
      };

  # fetchRepoProject = callPackage ./fetchrepoproject { };

  # fetchipfs = import ./fetchipfs {
  #   inherit curl stdenv;
  # };

  fetchzip = callPackage ./fetchzip { } // {
    tests = pkgs.tests.fetchzip;
  };

  # fetchDebianPatch = callPackage ./fetchdebianpatch { }
  #   // {
  #     tests = pkgs.tests.fetchDebianPatch;
  #   };

  fetchCrate = callPackage ./rust/fetchcrate.nix { };

  # fetchFromGitea = callPackage ./fetchgitea { };

  fetchFromGitHub = callPackage ./fetchgithub { };

  # fetchFromBitbucket = callPackage ./fetchbitbucket { };

  fetchFromSavannah = callPackage ./fetchsavannah { };

  # fetchFromSourcehut = callPackage ./fetchsourcehut { };

  fetchFromGitLab = callPackage ./fetchgitlab { };

  # fetchFromGitiles = callPackage ./fetchgitiles { };

  # fetchFrom9Front = callPackage ./fetch9front { };

  # fetchFromRepoOrCz = callPackage ./fetchrepoorcz { };

  # fetchgx = callPackage ./fetchgx { };

  fetchPypi = callPackage ./fetchpypi { };

  # fetchPypiLegacy = callPackage ./fetchpypilegacy { };

  # resolveMirrorURLs = {url}: fetchurl {
  #   showURLs = true;
  #   inherit url;
  # };

  installShellFiles = callPackage ./install-shell-files { };

  # ld-is-cc-hook = makeSetupHook { name = "ld-is-cc-hook"; }
  #   ./setup-hooks/ld-is-cc-hook.sh;

  libredirect = callPackage ./libredirect { };

  # copyDesktopItems = makeSetupHook {
  #   name = "copy-desktop-items-hook";
  # } ./setup-hooks/copy-desktop-items.sh;

  # makeDesktopItem = callPackage ./make-desktopitem { };

  # copyPkgconfigItems = makeSetupHook {
  #   name = "copy-pkg-config-items-hook";
  # } ./setup-hooks/copy-pkgconfig-items.sh;

  # makePkgconfigItem = callPackage ./make-pkgconfigitem { };

  # makeDarwinBundle = callPackage ./make-darwin-bundle { };

  # makeAutostartItem = callPackage ./make-startupitem { };

  # makeImpureTest = callPackage ./make-impure-test.nix;

  # makeInitrd = callPackage ./kernel/make-initrd.nix; # Args intentionally left out

  # makeInitrdNG = callPackage ./kernel/make-initrd-ng.nix;
  # makeInitrdNGTool = callPackage ./kernel/make-initrd-ng-tool.nix { };

  makeWrapper = makeShellWrapper;

  makeShellWrapper = makeSetupHook {
    name = "make-shell-wrapper-hook";
    propagatedBuildInputs = [ dieHook ];
    substitutions = {
      # targetPackages.runtimeShell only exists when pkgs == targetPackages (when targetPackages is not  __raw)
      shell =
        if targetPackages ? runtimeShell then
          targetPackages.runtimeShell
        else
          throw "makeWrapper/makeShellWrapper must be in nativeBuildInputs";
    };
    passthru = {
      tests = tests.makeWrapper;
    };
  } ./setup-hooks/make-wrapper.sh;

  makeBinaryWrapper = callPackage ./setup-hooks/make-binary-wrapper { };

  # compressFirmwareXz = callPackage ./kernel/compress-firmware-xz.nix { };

  # makeModulesClosure = { kernel, firmware, rootModules, allowMissing ? false }:
  #   callPackage ./kernel/modules-closure.nix {
  #     inherit kernel firmware rootModules allowMissing;
  #   };

  # mkBinaryCache = callPackage ./binary-cache { };

  # mkShell = callPackage ./mkshell { };
  # mkShellNoCC = mkShell.override { stdenv = stdenvNoCC; };

  # nixBufferBuilders = import ./emacs/buffer.nix { inherit lib writeText; inherit (emacs.pkgs) inherit-local; };

  # nix-gitignore = callPackage ./nix-gitignore { };

  # ociTools = callPackage ./oci-tools { };

  # inherit (
  #   callPackages ./setup-hooks/patch-rc-path-hooks { }
  # ) patchRcPathBash patchRcPathCsh patchRcPathFish patchRcPathPosix;

  # pathsFromGraph = ./kernel/paths-from-graph.pl;

  pruneLibtoolFiles = makeSetupHook {
    name = "prune-libtool-files";
  } ./setup-hooks/prune-libtool-files.sh;

  # closureInfo = callPackage ./closure-info.nix { };

  # setupSystemdUnits = callPackage ./setup-systemd-units.nix { };

  shortenPerlShebang = makeSetupHook {
    name = "shorten-perl-shebang-hook";
    propagatedBuildInputs = [ dieHook ];
  } ./setup-hooks/shorten-perl-shebang.sh;

  # singularity-tools = callPackage ./singularity-tools { };

  # srcOnly = callPackage ./src-only { };

  substitute = callPackage ./substitute/substitute.nix { };

  substituteAll = callPackage ./substitute/substitute-all.nix { };

  # substituteAllFiles = callPackage ./substitute-files/substitute-all-files.nix { };

  # replaceDependency = callPackage ./replace-dependency.nix { };

  nukeReferences = callPackage ./nuke-references { inherit (darwin) signingUtils; };

  # referencesByPopularity = callPackage ./references-by-popularity { };

  removeReferencesTo = callPackage ./remove-references-to { inherit (darwin) signingUtils; };

  # # No callPackage.  In particular, we don't want `img` *package* in parameters.
  # vmTools = makeOverridable (import ./vm) { inherit pkgs lib; };

  # releaseTools = callPackage ./release { };

  # inherit (lib.systems) platforms;

  # setJavaClassPath = makeSetupHook {
  #   name = "set-java-classpath-hook";
  # } ./setup-hooks/set-java-classpath.sh;

  fixDarwinDylibNames = makeSetupHook {
    name = "fix-darwin-dylib-names-hook";
    substitutions = {
      inherit (binutils) targetPrefix;
    };
    meta.platforms = lib.platforms.darwin;
  } ./setup-hooks/fix-darwin-dylib-names.sh;

  # writeDarwinBundle = callPackage ./make-darwin-bundle/write-darwin-bundle.nix { };

  # desktopToDarwinBundle = makeSetupHook {
  #   name = "desktop-to-darwin-bundle-hook";
  #   propagatedBuildInputs = [ writeDarwinBundle librsvg imagemagick python3Packages.icnsutil ];
  # } ./setup-hooks/desktop-to-darwin-bundle.sh;

  # keepBuildTree = makeSetupHook {
  #   name = "keep-build-tree-hook";
  # } ./setup-hooks/keep-build-tree.sh;

  # moveBuildTree = makeSetupHook {
  #   name = "move-build-tree-hook";
  # } ./setup-hooks/move-build-tree.sh;

  # enableGCOVInstrumentation = makeSetupHook {
  #   name = "enable-gcov-instrumentation-hook";
  # } ./setup-hooks/enable-coverage-instrumentation.sh;

  # makeGCOVReport = makeSetupHook {
  #   name = "make-gcov-report-hook";
  #   propagatedBuildInputs = [ lcov enableGCOVInstrumentation ];
  # } ./setup-hooks/make-coverage-analysis-report.sh;

  # makeHardcodeGsettingsPatch = callPackage ./make-hardcode-gsettings-patch { };

  # # intended to be used like nix-build -E 'with import <nixpkgs> { }; enableDebugging fooPackage'
  # enableDebugging = pkg: pkg.override { stdenv = stdenvAdapters.keepDebugInfo pkg.stdenv; };

  findXMLCatalogs = makeSetupHook {
    name = "find-xml-catalogs-hook";
  } ./setup-hooks/find-xml-catalogs.sh;

  # wrapGAppsHook = callPackage ./setup-hooks/wrap-gapps-hook {
  #   makeWrapper = makeBinaryWrapper;
  # };

  # wrapGAppsHook4 = wrapGAppsHook.override { gtk3 = __splicedPackages.gtk4; };

  # wrapGAppsNoGuiHook = wrapGAppsHook.override { isGraphical = false; };

  # separateDebugInfo = makeSetupHook {
  #   name = "separate-debug-info-hook";
  # } ./setup-hooks/separate-debug-info.sh;

  setupDebugInfoDirs = makeSetupHook {
    name = "setup-debug-info-dirs-hook";
  } ./setup-hooks/setup-debug-info-dirs.sh;

  # useOldCXXAbi = makeSetupHook {
  #   name = "use-old-cxx-abi-hook";
  # } ./setup-hooks/use-old-cxx-abi.sh;

  # iconConvTools = callPackage ./icon-conv-tools { };

  # validatePkgConfig = makeSetupHook
  #   { name = "validate-pkg-config"; propagatedBuildInputs = [ findutils pkg-config ]; }
  #   ./setup-hooks/validate-pkg-config.sh;

  # patchPpdFilesHook = callPackage ./setup-hooks/patch-ppd-files { };

  #package writers
  writers = callPackage ./writers { };

  # # lib functions depending on pkgs
  # inherit (import ../pkgs-lib {
  #   # The `lib` variable in this scope doesn't include any applied lib overlays,
  #   # `pkgs.lib` does.
  #   inherit (pkgs) lib;
  #   inherit pkgs;
  # }) formats;

  testers = callPackage ./testers { };

  # deterministic-uname = callPackage ./deterministic-uname { };

  wrapCCWith =
    {
      cc,
      # This should be the only bintools runtime dep with this sort of logic. The
      # Others should instead delegate to the next stage's choice with
      # `targetPackages.stdenv.cc.bintools`. This one is different just to
      # provide the default choice, avoiding infinite recursion.
      # See the bintools attribute for the logic and reasoning. We need to provide
      # a default here, since eval will hit this function when bootstrapping
      # stdenv where the bintools attribute doesn't exist, but will never actually
      # be evaluated -- callPackage ends up being too eager.
      bintools ? pkgs.bintools,
      libc ? bintools.libc,
      # libc++ from the default LLVM version is bound at the top level, but we
      # want the C++ library to be explicitly chosen by the caller, and null by
      # default.
      libcxx ? null,
      extraPackages ? lib.optional (cc.isGNU or false && stdenv.targetPlatform.isMinGW) (
        (threadsCrossFor cc.version).package
      ),
      nixSupport ? { },
      ...
    }@extraArgs:
    callPackage ./cc-wrapper (
      let
        self = {
          nativeTools = stdenv.targetPlatform == stdenv.hostPlatform && stdenv.cc.nativeTools or false;
          nativeLibc = stdenv.targetPlatform == stdenv.hostPlatform && stdenv.cc.nativeLibc or false;
          nativePrefix = stdenv.cc.nativePrefix or "";
          noLibc = !self.nativeLibc && (self.libc == null);

          isGNU = cc.isGNU or false;
          isClang = cc.isClang or false;

          inherit
            cc
            bintools
            libc
            libcxx
            extraPackages
            nixSupport
            zlib
            ;
        } // extraArgs;
      in
      self
    );

  wrapCC = cc: wrapCCWith { inherit cc; };

  wrapBintoolsWith =
    {
      bintools,
      libc ? if stdenv.targetPlatform != stdenv.hostPlatform then libcCross else stdenv.cc.libc,
      ...
    }@extraArgs:
    callPackage ./bintools-wrapper (
      let
        self = {
          nativeTools = stdenv.targetPlatform == stdenv.hostPlatform && stdenv.cc.nativeTools or false;
          nativeLibc = stdenv.targetPlatform == stdenv.hostPlatform && stdenv.cc.nativeLibc or false;
          nativePrefix = stdenv.cc.nativePrefix or "";

          noLibc = (self.libc == null);

          inherit bintools libc;
          inherit (darwin) postLinkSignHook signingUtils;
        } // extraArgs;
      in
      self
    );

  # sourceFromHead = callPackage ./source-from-head-fun.nix { };

  wrapRustcWith = { rustc-unwrapped, ... }@args: callPackage ./rust/rustc-wrapper args;
  wrapRustc = rustc-unwrapped: wrapRustcWith { inherit rustc-unwrapped; };
}