core/pkgs/by-name/bo/boost/generic.nix

{ lib, stdenv, icu, expat, zlib, bzip2, zstd, xz, python ? null
, fixDarwinDylibNames, libiconv, libxcrypt, boost-build, fetchpatch, which
, toolset ?
  if stdenv.cc.isClang then "clang" else if stdenv.cc.isGNU then "gcc" else null
, enableRelease ? true, enableDebug ? false, enableSingleThreaded ? false
, enableMultiThreaded ? true, enableShared ?
  !(with stdenv.hostPlatform; isStatic || isMinGW) # problems for now
, enableStatic ? !enableShared, enablePython ? false, enableNumpy ? false
, enableIcu ? stdenv.hostPlatform == stdenv.buildPlatform, taggedLayout ?
  ((enableRelease && enableDebug)
    || (enableSingleThreaded && enableMultiThreaded)
    || (enableShared && enableStatic)), patches ? [ ], boostBuildPatches ? [ ]
, useMpi ? false, mpi, extraB2Args ? [ ]

  # Attributes inherit from specific versions
, version, src, ... }:

# We must build at least one type of libraries
assert enableShared || enableStatic;

assert enableNumpy -> enablePython;

let

  variant = lib.concatStringsSep ","
    (lib.optional enableRelease "release" ++ lib.optional enableDebug "debug");

  threading = lib.concatStringsSep ","
    (lib.optional enableSingleThreaded "single"
      ++ lib.optional enableMultiThreaded "multi");

  link = lib.concatStringsSep ","
    (lib.optional enableShared "shared" ++ lib.optional enableStatic "static");

  runtime-link = if enableShared then "shared" else "static";

  # To avoid library name collisions
  layout = if taggedLayout then "tagged" else "system";

  needUserConfig = stdenv.hostPlatform != stdenv.buildPlatform || useMpi
    || (stdenv.isDarwin && enableShared);

  b2Args = lib.concatStringsSep " " ([
    "--includedir=$dev/include"
    "--libdir=$out/lib"
    "-j$NIX_BUILD_CORES"
    "--layout=${layout}"
    "variant=${variant}"
    "threading=${threading}"
    "link=${link}"
    "-sEXPAT_INCLUDE=${expat.dev}/include"
    "-sEXPAT_LIBPATH=${expat.out}/lib"

    # TODO: make this unconditional
  ] ++ lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform ||
    # required on mips; see 61d9f201baeef4c4bb91ad8a8f5f89b747e0dfe4
    (stdenv.hostPlatform.isMips && lib.versionAtLeast version "1.79")) [
      "address-model=${toString stdenv.hostPlatform.parsed.cpu.bits}"
      "architecture=${
        if stdenv.hostPlatform.isMips64 then
          if lib.versionOlder version "1.78" then "mips1" else "mips"
        else if stdenv.hostPlatform.parsed.cpu.name == "s390x" then
          "s390x"
        else
          toString stdenv.hostPlatform.parsed.cpu.family
      }"
      # env in host triplet for Mach-O is "macho", but boost binary format for Mach-O is "mach-o"
      "binary-format=${
        if stdenv.hostPlatform.isMacho then
          "mach-o"
        else
          toString stdenv.hostPlatform.parsed.kernel.execFormat.name
      }"
      "target-os=${toString stdenv.hostPlatform.parsed.kernel.name}"

      # adapted from table in boost manual
      # https://www.boost.org/doc/libs/1_66_0/libs/context/doc/html/context/architectures.html
      "abi=${
        if stdenv.hostPlatform.parsed.cpu.family == "arm" then
          "aapcs"
        else if stdenv.hostPlatform.isWindows then
          "ms"
        else if stdenv.hostPlatform.isMips32 then
          "o32"
        else if stdenv.hostPlatform.isMips64n64 then
          "n64"
        else
          "sysv"
      }"
    ] ++ lib.optional (link != "static") "runtime-link=${runtime-link}"
    ++ lib.optional (variant == "release") "debug-symbols=off"
    ++ lib.optional (toolset != null) "toolset=${toolset}"
    ++ lib.optional (!enablePython) "--without-python"
    ++ lib.optional needUserConfig "--user-config=user-config.jam"
    ++ lib.optional
    (stdenv.buildPlatform.isDarwin && stdenv.hostPlatform.isLinux) "pch=off"
    ++ lib.optionals stdenv.hostPlatform.isMinGW [ "threadapi=win32" ]
    ++ extraB2Args);

in stdenv.mkDerivation {
  pname = "boost";

  inherit src version;

  patchFlags = [ ];

  patches = patches
    ++ lib.optional stdenv.isDarwin ./darwin-no-system-python.patch
    ++ [ ./cmake-paths-173.patch ] ++ lib.optional (version == "1.77.0")
    (fetchpatch {
      url =
        "https://github.com/boostorg/math/commit/7d482f6ebc356e6ec455ccb5f51a23971bf6ce5b.patch";
      relative = "include";
      sha256 = "sha256-KlmIbixcds6GyKYt1fx5BxDIrU7msrgDdYo9Va/KJR4=";
    })
    # Fixes ABI detection
    ++ lib.optional (version == "1.83.0") (fetchpatch {
      url =
        "https://github.com/boostorg/context/commit/6fa6d5c50d120e69b2d8a1c0d2256ee933e94b3b.patch";
      stripLen = 1;
      extraPrefix = "libs/context/";
      sha256 = "sha256-bCfLL7bD1Rn4Ie/P3X+nIcgTkbXdCX6FW7B9lHsmVW8=";
    })
    # This fixes another issue regarding ill-formed constant expressions, which is a default error
    # in clang 16 and will be a hard error in clang 17.
    ++ lib.optional (lib.versionOlder version "1.80") (fetchpatch {
      url =
        "https://github.com/boostorg/log/commit/77f1e20bd69c2e7a9e25e6a9818ae6105f7d070c.patch";
      relative = "include";
      hash = "sha256-6qOiGJASm33XzwoxVZfKJd7sTlQ5yd+MMFQzegXm5RI=";
    }) ++ lib.optionals (lib.versionOlder version "1.81") [
      # libc++ 15 dropped support for `std::unary_function` and `std::binary_function` in C++17+.
      # C++17 is the default for clang 16, but clang 15 is also affected in that language mode.
      # This patch is for Boost 1.80, but it also applies to earlier versions.
      (fetchpatch {
        url = "https://www.boost.org/patches/1_80_0/0005-config-libcpp15.patch";
        hash = "sha256-ULFMzKphv70unvPZ3o4vSP/01/xbSM9a2TlIV67eXDQ=";
      })
      # This fixes another ill-formed contant expressions issue flagged by clang 16.
      (fetchpatch {
        url =
          "https://github.com/boostorg/numeric_conversion/commit/50a1eae942effb0a9b90724323ef8f2a67e7984a.patch";
        relative = "include";
        hash = "sha256-dq4SVgxkPJSC7Fvr59VGnXkM4Lb09kYDaBksCHo9C0s=";
      })
      # This fixes an issue in Python 3.11 about Py_TPFLAGS_HAVE_GC
      (fetchpatch {
        name = "python311-compatibility.patch";
        url =
          "https://github.com/boostorg/python/commit/a218babc8daee904a83f550fb66e5cb3f1cb3013.patch";
        hash = "sha256-IHxLtJBx0xSy7QEr8FbCPofsjcPuSYzgtPwDlx1JM+4=";
        stripLen = 1;
        extraPrefix = "libs/python/";
      })
    ];

  meta = with lib; {
    homepage = "http://boost.org/";
    description = "Collection of C++ libraries";
    license = licenses.boost;
    platforms = platforms.unix ++ platforms.windows;
    # boost-context lacks support for the N32 ABI on mips64.  The build
    # will succeed, but packages depending on boost-context will fail with
    # a very cryptic error message.
    badPlatforms = [ lib.systems.inspect.patterns.isMips64n32 ];
    maintainers = with maintainers; [ hjones2199 ];
  };

  # passthru = {
  #   inherit boostBuildPatches;
  # };

  preConfigure = lib.optionalString useMpi ''
    cat << EOF >> user-config.jam
    using mpi : ${lib.getDev mpi}/bin/mpiCC ;
    EOF
  ''
    # On darwin we need to add the `$out/lib` to the libraries' rpath explicitly,
    # otherwise the dynamic linker is unable to resolve the reference to @rpath
    # when the boost libraries want to load each other at runtime.
    + lib.optionalString (stdenv.isDarwin && enableShared) ''
      cat << EOF >> user-config.jam
      using clang-darwin : : ${stdenv.cc.targetPrefix}c++
        : <linkflags>"-rpath $out/lib/"
        ;
      EOF
    ''
    # b2 has trouble finding the correct compiler and tools for cross compilation
    # since it apparently ignores $CC, $AR etc. Thus we need to set everything
    # in user-config.jam. To keep things simple we just set everything in an
    # uniform way for clang and gcc (which works thanks to our cc-wrapper).
    # We pass toolset later which will make b2 invoke everything in the right
    # way -- the other toolset in user-config.jam will be ignored.
    + lib.optionalString (stdenv.hostPlatform != stdenv.buildPlatform) ''
      cat << EOF >> user-config.jam
      using gcc : cross : ${stdenv.cc.targetPrefix}c++
        : <archiver>$AR
          <ranlib>$RANLIB
        ;

      using clang : cross : ${stdenv.cc.targetPrefix}c++
        : <archiver>$AR
          <ranlib>$RANLIB
        ;
      EOF
    ''
    # b2 needs to be explicitly told how to find Python when cross-compiling
    + lib.optionalString enablePython ''
      cat << EOF >> user-config.jam
      using python : : ${python.interpreter}
        : ${python}/include/python${python.pythonVersion}
        : ${python}/lib
        ;
      EOF
    '';

  NIX_CFLAGS_LINK =
    lib.optionalString stdenv.isDarwin "-headerpad_max_install_names";

  enableParallelBuilding = true;

  nativeBuildInputs = [ which boost-build ]
    ++ lib.optional stdenv.hostPlatform.isDarwin fixDarwinDylibNames;
  buildInputs = [ expat zlib bzip2 libiconv ]
    ++ lib.optional (lib.versionAtLeast version "1.69") zstd ++ [ xz ]
    ++ lib.optional enableIcu icu
    ++ lib.optionals enablePython [ libxcrypt python ]
    ++ lib.optional enableNumpy python.pkgs.numpy;

  configureScript = "./bootstrap.sh";
  configurePlatforms = [ ];
  dontDisableStatic = true;
  dontAddStaticConfigureFlags = true;
  configureFlags = [
    "--includedir=$(dev)/include"
    "--libdir=$(out)/lib"
    "--with-bjam=b2" # prevent bootstrapping b2 in configurePhase
  ] ++ lib.optional (toolset != null) "--with-toolset=${toolset}"
    ++ [ (if enableIcu then "--with-icu=${icu.dev}" else "--without-icu") ];

  buildPhase = ''
    runHook preBuild
    b2 ${b2Args}
    runHook postBuild
  '';

  installPhase = ''
    runHook preInstall

    # boostbook is needed by some applications
    mkdir -p $dev/share/boostbook
    cp -a tools/boostbook/{xsl,dtd} $dev/share/boostbook/

    # Let boost install everything else
    b2 ${b2Args} install

    runHook postInstall
  '';

  postFixup = ''
    # Make boost header paths relative so that they are not runtime dependencies
    cd "$dev" && find include \( -name '*.hpp' -or -name '*.h' -or -name '*.ipp' \) \
      -exec sed '1s/^\xef\xbb\xbf//;1i#line 1 "{}"' -i '{}' \;
  '' + lib.optionalString stdenv.hostPlatform.isMinGW ''
    $RANLIB "$out/lib/"*.a
  '';

  outputs = [ "out" "dev" ];
  setOutputFlags = false;
}