#!/bin/bash

export LINUX_VERSION="6.12.1"

# Backup the native environment
export BUILD_CC="$BUILD_CC"
export CC_native="$CC"
export CPP_native="$CPP"
export CXX_native="$CXX"
export AS_native="$AS"
export LD_native="$LD"
export AR_native="$AR"
export NM_native="$NM"
export RANLIB_native="$RANLIB"
export STRIP_native="$STRIP"
export OBJDUMP_native="$OBJDUMP"
export READELF_native="$READELF"
export CFLAGS_native="$CFLAGS_native"
export CPPFLAGS_native="$CPPFLAGS"
export CXXFLAGS_native="$CXXFLAGS"
export LDFLAGS_native="$LDFLAGS"
export LD_LIBRARY_PATH_native="$LD_LIBRARY_PATH"
export PKG_CONFIG_LIBDIR_native="$PKG_CONFIG_LIBDIR"

# Function to handle errors
error_handler() {
    local exit_code=$?
    local line_number=$1
    local file_name=$2
    echo "Error in file: $file_name, line: $line_number, reason: Command exited with status $exit_code"
}

# Set the trap to catch errors
trap 'error_handler $LINENO $0' ERR

set -eo pipefail

if [ ! -d "./sources" ]; then
    echo "Run this script from the right directory"
    exit 1
fi

export BASE_DIR=$(pwd)

if [ -z "$KERNEL_ARCH" ]; then
    echo "You must set a kernel target architecture among supported ones:"
    echo "i386"
    echo "x86_64"
    echo "arm"

    exit 1
fi

if [ -z "$TARGET_TRIPLET_ARCH" ] || [ -z "$TARGET_TRIPLET_VENDOR" ] || [ -z "$TARGET_TRIPLET_OS" ] || [ -z "$TARGET_TRIPLET_GNUEABI" ]; then
    echo "You MUST define TARGET_TRIPLET_ARCH, TARGET_TRIPLET_VENDOR, TARGET_TRIPLET_OS and TARGET_TRIPLET_GNUEABI"
    exit 1
fi

export TARGET_MACHINE_TRIPLET="$TARGET_TRIPLET_ARCH-$TARGET_TRIPLET_VENDOR-$TARGET_TRIPLET_OS-$TARGET_TRIPLET_GNUEABI"
export LFS="$(pwd)/out/$TARGET_MACHINE_TRIPLET/rootfs"

bash version-check.sh

export BUILD_MACHINE_TRIPLET=$(gcc -dumpmachine)

# Create the target directory
export STEPS_DIR="$LFS/../steps/"
export TMP_BUILD_DIR="$LFS/../build/"
export CROSS_TOOLS_DIR="$LFS/tools"

mkdir -p "$LFS"
mkdir -vp "$STEPS_DIR"
mkdir -vp "$CROSS_TOOLS_DIR"
mkdir -vp "$TMP_BUILD_DIR"

export PATH="$CROSS_TOOLS_DIR/bin/:$PATH"

unset CFLAGS
unset LDFLAGS

setup_toolchain() {
    export BUILD_CC=gcc
    export CC="$TARGET_MACHINE_TRIPLET-gcc"
    export CPP="$TARGET_MACHINE_TRIPLET-cpp"
    export CXX="$TARGET_MACHINE_TRIPLET-g++"
    export AS="$TARGET_MACHINE_TRIPLET-as"
    export LD="$TARGET_MACHINE_TRIPLET-ld"
    export AR="$TARGET_MACHINE_TRIPLET-ar"
    export NM="$TARGET_MACHINE_TRIPLET-nm"
    export RANLIB="$TARGET_MACHINE_TRIPLET-ranlib"
    export STRIP="$TARGET_MACHINE_TRIPLET-strip"
    export OBJDUMP="$TARGET_MACHINE_TRIPLET-objdump"
    export READELF="$TARGET_MACHINE_TRIPLET-readelf"
    export CPPFLAGS=""
    export CFLAGS="   $TARGET_ADDITIONAL_CFLAGS -U_FORTIFY_SOURCE -O2 -L$CROSS_TOOLS_DIR/lib -L$LFS/usr/lib -I$CROSS_TOOLS_DIR/include -I$CROSS_TOOLS_DIR/$TARGET_MACHINE_TRIPLET/include"
    export CXXFLAGS=" $TARGET_ADDITIONAL_CFLAGS -U_FORTIFY_SOURCE -O2 -L$CROSS_TOOLS_DIR/lib -L$LFS/usr/lib -I$CROSS_TOOLS_DIR/include -I$CROSS_TOOLS_DIR/$TARGET_MACHINE_TRIPLET/include -I$CROSS_TOOLS_DIR/$TARGET_MACHINE_TRIPLET/include/c++/14.2.0/ -I$CROSS_TOOLS_DIR/$TARGET_MACHINE_TRIPLET/include/c++/14.2.0/$TARGET_MACHINE_TRIPLET"
    export LDFLAGS="  -L$LFS/usr/lib -L$CROSS_TOOLS_DIR/lib"
    export LD_LIBRARY_PATH_old="$LD_LIBRARY_PATH"
    export LD_LIBRARY_PATH="$CROSS_TOOLS_DIR/lib $LFS/usr/lib"
    export PKG_CONFIG_LIBDIR="$CROSS_TOOLS_DIR/lib $LFS/usr/lib"
    export SYSROOT="$LFS"
    #unset LD_LIBRARY_PATH

    echo "[binaries]" > meson_cross.txt
    echo "c = '$CC'" >> meson_cross.txt
    echo "cpp = '$CPP'" >> meson_cross.txt
    echo "ar = '$AR'" >> meson_cross.txt
    #echo "windres = 'x86_64-w64-mingw32-windres'" >> meson_cross.txt
    echo "strip = '$STRIP'" >> meson_cross.txt
    echo "exe_wrapper = 'wine64'" >> meson_cross.txt
    echo "" >> meson_cross.txt
    echo "[host_machine]" >> meson_cross.txt
    echo "system = 'linux'" >> meson_cross.txt
    echo "cpu_family = '$CPU_FAMILY'" >> meson_cross.txt
    echo "cpu = '$CPU'" >> meson_cross.txt
    echo "endian = '$TARGET_ENDIANNESS'" >> meson_cross.txt
}

host_toolchain() {
    export BUILD_CC="$BUILD_CC_native"
    export CC="$CC_native"
    export CXX="$CXX_native"
    export CPP="$CPP_native"
    export AS="$AS_native"
    export LD="$LD_native"
    export AR="$AR_native"
    export NM="$NM_native"
    export RANLIB="$RANLIB_native"
    export STRIP="$STRIP_native"
    export OBJDUMP="$OBJDUMP_native"
    export READELF="$READELF_native"
    export CFLAGS="$CFLAGS_native"
    export CPPFLAGS="$CPPFLAGS_native"
    export CXXFLAGS="$CXXFLAGS_native"
    export LDFLAGS="$LDFLAGS_native"
    export PKG_CONFIG_LIBDIR="$PKG_CONFIG_LIBDIR_native"
    export LD_LIBRARY_PATH="$LD_LIBRARY_PATH_native"
}

# Create a directory layout
if [ ! -d "$LFS/etc" ]; then
    mkdir -pv $LFS/{etc,var} $LFS/usr/{bin,lib,share}
    mkdir -pv $LFS/{dev,proc,sys,run,tmp}

    # like archlinux sbin->/usr/bin
    ln -sv usr/bin $LFS/sbin
    ln -sv bin $LFS/usr/sbin

    for i in bin lib; do
        ln -sv usr/$i $LFS/$i
    done
fi

# Build binutils
if [ ! -f "$STEPS_DIR/binutils" ]; then
    if [ ! -d "$TMP_BUILD_DIR/binutils" ]; then
        tar -xf "$BASE_DIR/sources/binutils-2.43.tar.zst"
        mv "binutils-2.43" "$TMP_BUILD_DIR/binutils"
    fi
    cd "$TMP_BUILD_DIR/binutils"

    mkdir -vp build
    cd        build
    "../configure"                       \
        --prefix=$CROSS_TOOLS_DIR        \
        --with-sysroot=$LFS              \
        --target=$TARGET_MACHINE_TRIPLET \
        --with-gnu-as                    \
        --with-gnu-ld                    \
        --enable-ld=default              \
        --enable-shared                  \
        --disable-nls                    \
        --enable-gprofng=no              \
        --disable-werror                 \
        --enable-new-dtags               \
        --disable-multilib               \
        --disable-libquadmath            \
        --disable-libquadmath-support    \
        --enable-plugins                 \
        --enable-deterministic-archives  \
        --enable-default-hash-style=gnu

    make -j 32
    make -j 32 install

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/binutils"
    touch "$STEPS_DIR/binutils"
fi

# Install kernel headers
if [ ! -f "$STEPS_DIR/linux-headers" ]; then
    if [ ! -d "$TMP_BUILD_DIR/linux" ]; then
        tar -xzf "$BASE_DIR/sources/linux-$LINUX_VERSION.tar.gz"
        mv "linux-$LINUX_VERSION" "$TMP_BUILD_DIR/linux"
    fi
    cd "$TMP_BUILD_DIR/linux"
    make mrproper
    make headers_install ARCH="$KERNEL_ARCH" INSTALL_HDR_PATH="$LFS/usr"
    cd "$BASE_DIR"
    #rm -rf "$TMP_BUILD_DIR/linux"
    touch "$STEPS_DIR/linux-headers"
fi

export CFLAGS="$CFLAGS -static "
export LDFLAGS="$LDFLAGS -Bstatic "

# Build gcc
if [ ! -f "$STEPS_DIR/gcc-step1" ]; then
    bash unpack-gcc.sh "$TMP_BUILD_DIR/"
    cd "$TMP_BUILD_DIR/gcc/"

    mkdir -vp build-step1
    cd        build-step1

    "../configure"                       \
        --target=$TARGET_MACHINE_TRIPLET \
        --host=${BUILD_MACHINE_TRIPLET}  \
        --build=${BUILD_MACHINE_TRIPLET} \
        --prefix=$CROSS_TOOLS_DIR        \
        --with-glibc-version=2.40        \
        --with-sysroot=$LFS              \
        --with-newlib                    \
        --disable-gdbtk                  \
        --disable-shared                 \
        --without-headers                \
        --enable-default-pie             \
        --enable-default-ssp             \
        --disable-nls                    \
        --disable-multilib               \
        --disable-threads                \
        --disable-libatomic              \
        --disable-libmudflap             \
        --disable-libgomp                \
        --disable-libquadmath            \
        --disable-libquadmath-support    \
        --disable-libssp                 \
        --disable-libvtv                 \
        --disable-libstdcxx              \
        --disable-decimal-float          \
        --disable-libsanitizer           \
        --enable-languages=c
    make -j 32 all-gcc # if build fails add --disable-libsanitizer
    make -j 32 install-gcc
    make check-gcc RUNTESTFLAGS=--target_board=${TARGET_TRIPLET_ARCH}-sim
    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/gcc/build" # Do not remove the whole gcc directory: we need it for libstdc++
    touch "$STEPS_DIR/gcc-step1"
fi

# From now on use
export BUILD_CC=gcc
export CC="$TARGET_MACHINE_TRIPLET-gcc"
export CXX="$TARGET_MACHINE_TRIPLET-g++"
export AS="$TARGET_MACHINE_TRIPLET-as"
export LD="$TARGET_MACHINE_TRIPLET-ld"
export AR="$TARGET_MACHINE_TRIPLET-ar"
export RANLIB="$TARGET_MACHINE_TRIPLET-ranlib"
export STRIP="$TARGET_MACHINE_TRIPLET-strip"
export OBJDUMP="$TARGET_MACHINE_TRIPLET-objdump"
export LDFLAGS=" -Bstatic "
# remove hardening options for building libraries
export CFLAGS="-U_FORTIFY_SOURCE -O2 -static"
export CPPFLAGS="-U_FORTIFY_SOURCE -O2 -static"
export LD_LIBRARY_PATH_old="$LD_LIBRARY_PATH"
unset LD_LIBRARY_PATH

# build glibc
if [ ! -f "$STEPS_DIR/glibc" ]; then
    if [ ! -d "$TMP_BUILD_DIR/glibc" ]; then
        tar -xzf "$BASE_DIR/sources/glibc-2.40.tar.gz"
        mv "glibc-2.40" "$TMP_BUILD_DIR/glibc"
    fi
    cd "$TMP_BUILD_DIR/glibc"

    mkdir -vp build
    cd        build

    echo "rootsbindir=/usr/sbin" > configparms
    echo 'slibdir=/lib' >> configparms
    echo 'rtlddir=/lib' >> configparms
    echo 'sbindir=/bin' >> configparms
    echo 'build-programs=no' >> configparms
    
    "../configure"                         \
      --prefix=/usr                        \
      --target=$TARGET_MACHINE_TRIPLET     \
      --host=$TARGET_MACHINE_TRIPLET       \
      --build=${BUILD_MACHINE_TRIPLET}     \
      --with-headers=$LFS/usr/include      \
      --with-binutils=$CROSS_TOOLS_DIR/bin \
      --without-cvs                        \
      --disable-nls                        \
      --disable-sanity-checks              \
      --enable-kernel=4.19                 \
      --disable-debug                      \
      --disable-profile                    \
      --without-selinux                    \
      --without-gd                         \
      --disable-nscd                       \
      --enable-hacker-mode                 \
      libc_cv_slibdir=/usr/lib             \
      libc_cv_forced_unwind=yes            \
      libc_cv_c_cleanup=yes

    make install-bootstrap-headers=yes install_root=$LFS install-headers

    make -j4 csu/subdir_lib

    if [ -f "csu/crt1.o" ]; then
        install csu/crt1.o $LFS/usr/lib
    fi

    if [ -f "csu/crti.o" ]; then
        install csu/crti.o $LFS/usr/lib
    fi

    if [ -f "csu/crtn.o" ]; then
        install csu/crtn.o $LFS/usr/lib
    fi

    if [ -f "csu/Scrt1.o" ]; then
        install csu/Scrt1.o $LFS/usr/lib
    fi

    if [ -f "csu/crtbeginS.o" ]; then
        install csu/crtbeginS.o $LFS/usr/lib
    fi

    $TARGET_MACHINE_TRIPLET-gcc \
        -nostdlib \
        -nostartfiles \
        -shared \
        -x c /dev/null \
        -o $LFS/usr/lib/libc.so
    touch $LFS/usr/include/gnu/stubs.h

    cd "$BASE_DIR"
    #rm -rf "$TMP_BUILD_DIR/glibc"
    touch "$STEPS_DIR/glibc"
fi

unset CC
unset CXX
unset LD
unset AS
unset AR
unset RANLIB
unset STRIP
unset OBJDUMP
export LD_LIBRARY_PATH="$LD_LIBRARY_PATH_old"
export CFLAGS="-U_FORTIFY_SOURCE -O2 -static "
export LDFLAGS="-U_FORTIFY_SOURCE -O2 -Bstatic "

if [ ! -f "$STEPS_DIR/gcc-step2" ]; then
    bash unpack-gcc.sh "$TMP_BUILD_DIR/"
    cd "$TMP_BUILD_DIR/gcc"

    mkdir -vp build-step2
    cd        build-step2

    # ../configure is already done
    "../configure"                       \
        --target=$TARGET_MACHINE_TRIPLET \
        --host=${BUILD_MACHINE_TRIPLET}  \
        --build=${BUILD_MACHINE_TRIPLET} \
        --prefix=$CROSS_TOOLS_DIR        \
        --with-glibc-version=2.40        \
        --with-sysroot=$LFS              \
        --enable-c99                     \
        --enable-long-long               \
        --enable-default-pie             \
        --enable-default-ssp             \
        --disable-nls                    \
        --disable-multilib               \
        --disable-libatomic              \
        --disable-libmudflap             \
        --disable-libgomp                \
        --disable-libquadmath            \
        --disable-libquadmath-support    \
        --disable-libssp                 \
        --disable-libvtv                 \
        --disable-libstdcxx              \
        --disable-decimal-float          \
        --disable-libsanitizer           \
        --enable-languages=c

    make -j 32 # if build fails add --disable-libsanitizer
    make -j 32 install

    cd "$BASE_DIR"
    #rm -rf "$TMP_BUILD_DIR/gcc/build" # Do not remove the whole gcc directory: we need it for libstdc++
    touch "$STEPS_DIR/gcc-step2"
fi

unset CFLAGS
unset LDFLAGS

if [ ! -f "$STEPS_DIR/glibc-step2" ]; then
    if [ ! -d "$TMP_BUILD_DIR/glibc/build" ]; then
        echo "'$TMP_BUILD_DIR/glibc/build' is supposed to exist. Error."
        exit 1
    fi
    cd "$TMP_BUILD_DIR/glibc/build"

    # Configuration is done already

    # Remove the stub glibc from before
    rm $LFS/usr/lib/libc.so

    make -j 32
    make -j 32 install_root=$LFS install

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/glibc"
    touch "$STEPS_DIR/glibc-step2"
fi

export CFLAGS="-U_FORTIFY_SOURCE -O2  -static "
export LDFLAGS="-U_FORTIFY_SOURCE -O2  -Bstatic "

# build the rest of gcc
if [ ! -f "$STEPS_DIR/gcc-step3" ]; then
    bash unpack-gcc.sh "$TMP_BUILD_DIR/"
    cd "$TMP_BUILD_DIR/gcc/"
    
    mkdir -vp build-step3
    cd        build-step3

    "../configure"                       \
        --target=$TARGET_MACHINE_TRIPLET \
        --host=${BUILD_MACHINE_TRIPLET}  \
        --build=${BUILD_MACHINE_TRIPLET} \
        --prefix=$CROSS_TOOLS_DIR        \
        --with-glibc-version=2.40        \
        --with-sysroot=$LFS              \
        --enable-c99                     \
        --enable-long-long               \
        --enable-default-pie             \
        --enable-default-ssp             \
        --disable-nls                    \
        --disable-multilib               \
        --disable-libgomp                \
        --disable-libquadmath            \
        --disable-libquadmath-support    \
        --disable-decimal-float          \
        --enable-languages=c,c++

    # Reebuild everything now that we have bootstrapped an initial gcc and glibc 
    make -j 32 # if build fails add --disable-libsanitizer
    make -j 32 install

    #make -j 32 DESTDIR="$LFS" install-target-libgcc

    cd "$BASE_DIR"
    #rm -rf "$TMP_BUILD_DIR/gcc"
    touch "$STEPS_DIR/gcc-step3"
fi

if [ ! -f "$STEPS_DIR/gcc-final" ]; then
    bash unpack-gcc.sh "$TMP_BUILD_DIR/"
    cd "$TMP_BUILD_DIR/gcc"

    mkdir -vp build-final
    cd        build-final

    # ../configure is already done
    "../configure"                       \
        --target=$TARGET_MACHINE_TRIPLET \
        --host=${BUILD_MACHINE_TRIPLET}  \
        --build=${BUILD_MACHINE_TRIPLET} \
        --prefix=$CROSS_TOOLS_DIR        \
        --with-glibc-version=2.40        \
        --with-sysroot=$LFS              \
        --enable-c99                     \
        --enable-long-long               \
        --enable-default-pie             \
        --enable-default-ssp             \
        --enable-nls                     \
        --disable-multilib               \
        --enable-libatomic               \
        --enable-libmudflap              \
        --enable-libgomp                 \
        --enable-libquadmath             \
        --enable-libquadmath-support     \
        --enable-libssp                  \
        --enable-libvtv                  \
        --enable-libstdcxx               \
        --enable-decimal-float           \
        --enable-languages=c,c++,objc,go

    make -j 32 # if build fails add --disable-libsanitizer
    make -j 32 install

    cd "$BASE_DIR"
    #rm -rf "$TMP_BUILD_DIR/gcc/build"
    touch "$STEPS_DIR/gcc-final"
fi

## finish the host toolchain
#host_toolchain
#bash "build-host-tools.sh"

# From now on use the new toolchain
setup_toolchain

# test the cross toolchain
which -- $TARGET_MACHINE_TRIPLET-as || echo $TARGET_MACHINE_TRIPLET-as is not in the PATH

"$CC" $CFLAGS -std=c11 -xc -latomic testvec.c
"$READELF" -l a.out | grep ld-linux
rm -v a.out

"$CXX" $CPPFLAGS -xc++ test_compiler.cpp
"$TARGET_MACHINE_TRIPLET-readelf" -l a.out
rm -v a.out

# build m4
if [ ! -f "$STEPS_DIR/m4" ]; then
    if [ ! -d "$TMP_BUILD_DIR/m4" ]; then
        tar -xzf "$BASE_DIR/sources/m4-1.4.19.tar.gz"
        mv "m4-1.4.19" "$TMP_BUILD_DIR/m4"
    fi
    cd "$TMP_BUILD_DIR/m4"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    echo "rootsbindir=/usr/sbin" > configparms

    "../configure"                       \
        --prefix=/usr                    \
        --build=${BUILD_MACHINE_TRIPLET} \
        --host=$TARGET_MACHINE_TRIPLET
    
    make -j 32
    make DESTDIR=$LFS install

    "$TARGET_MACHINE_TRIPLET-strip" --strip-unneeded $LFS/usr/bin/m4

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/m4"
    touch "$STEPS_DIR/m4"
fi

# build attr
if [ ! -f "$STEPS_DIR/attr" ]; then
    if [ ! -d "$TMP_BUILD_DIR/attr" ]; then
        tar -xzf "$BASE_DIR/sources/attr-2.5.2.tar.gz"
        mv "attr-2.5.2" "$TMP_BUILD_DIR/attr"
    fi
    cd "$TMP_BUILD_DIR/attr"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    echo "rootsbindir=/usr/bin" > configparms

    "../configure"                        \
        --prefix=/usr                     \
        --with-sysroot=${LFS}             \
        --disable-static                  \
        --host=$TARGET_MACHINE_TRIPLET

    make -j 32
    make -j 32 DESTDIR="$LFS" install

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/attr"
    touch "$STEPS_DIR/attr"
fi

# build zlib
if [ ! -f "$STEPS_DIR/zlib" ]; then
    if [ ! -d "$TMP_BUILD_DIR/zlib" ]; then
        tar -xzf "$BASE_DIR/sources/zlib-1.3.1.tar.gz"
        mv "zlib-1.3.1" "$TMP_BUILD_DIR/zlib"
    fi
    cd "$TMP_BUILD_DIR/zlib"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    export CFLAGS_old="$CFLAGS"
    export CFLAGS+=" -ffat-lto-objects"

    "../configure"                        \
        --prefix=/usr                     \
        --enable-shared
    
    make -j 32
    make -j 32 DESTDIR="$LFS" install

    export CFLAGS="$CFLAGS_old"

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/zlib"
    touch "$STEPS_DIR/zlib"
fi

# build openssl
if [ ! -f "$STEPS_DIR/openssl" ]; then
    if [ ! -d "$TMP_BUILD_DIR/openssl" ]; then
        tar -xf "$BASE_DIR/sources/openssl-3.4.0.tar.gz"
        mv "openssl-3.4.0" "$TMP_BUILD_DIR/openssl"
        cd "$TMP_BUILD_DIR/openssl"
        cp $BASE_DIR/sources/openssl-ca-dir.patch .
        patch -Np1 -i "./openssl-ca-dir.patch"
    fi
    cd "$TMP_BUILD_DIR/openssl"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    # TODO: # enable-ec_nistp_64_gcc_128
    "../Configure"                          \
        --prefix=/usr                       \
        --openssldir=/etc/ssl               \
        --libdir=/usr/lib                   \
        shared zlib enable-ktls "${OPENSSL_ARCH}"

    make -j 32 depend apps/CA.pl
    make -j 32 all
    make -j 32 DESTDIR="$LFS" MANDIR=/usr/share/man MANSUFFIX=ssl install_sw install_ssldirs install_man_docs

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/openssl"
    touch "$STEPS_DIR/openssl"
fi

# build libxcrypt
if [ ! -f "$STEPS_DIR/libxcrypt" ]; then
    if [ ! -d "$TMP_BUILD_DIR/libxcrypt" ]; then
        tar -xf "$BASE_DIR/sources/libxcrypt-4.4.36.tar.xz"
        mv "libxcrypt-4.4.36" "$TMP_BUILD_DIR/libxcrypt"
    fi
    cd "$TMP_BUILD_DIR/libxcrypt"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    "../configure"                       \
        --prefix=/usr                    \
        --disable-static                 \
        --enable-hashes=strong,glibc     \
        --with-sysroot=${LFS}            \
        --host=${TARGET_MACHINE_TRIPLET} \
        --build=${BUILD_MACHINE_TRIPLET} \
        --enable-obsolete-api=no         \
        --disable-failure-tokens         \
        --cache-file=config.cache

    make -j 32
    make -j 32 DESTDIR=$LFS install

    #cd ..
    #mkdir -vp build-compat-$TARGET_MACHINE_TRIPLET
    #cd        build-compat-$TARGET_MACHINE_TRIPLET

    #"../configure"                       \
    #    --prefix=/usr                    \
    #    --disable-static                 \
    #    --enable-hashes=strong,glibc     \
    #    --with-sysroot=${LFS}            \
    #    --host=${TARGET_MACHINE_TRIPLET} \
    #    --build=${BUILD_MACHINE_TRIPLET} \
    #    --enable-obsolete-api=glibc      \
    #    --disable-failure-tokens         \
    #    --cache-file=config.cache

    # DO NOT MAKE: check archlinux package!

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/libxcrypt"
    touch "$STEPS_DIR/libxcrypt"
fi

# build ncurses
# TODO: fix symlink!!!
if [ ! -f "$STEPS_DIR/ncurses" ]; then
    if [ ! -d "$TMP_BUILD_DIR/ncurses" ]; then
        tar -xzf "$BASE_DIR/sources/ncurses.tar.gz"
        mv "ncurses-6.3" "$TMP_BUILD_DIR/ncurses"
    fi
    cd "$TMP_BUILD_DIR/ncurses"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    # --with-cxx-binding no c++?
    # --with-cxx-shared no c++?
    # --disable-stripping does not work for all architectures because the system strip is used
    "../configure"                       \
        --prefix=/usr                    \
        --sysconfdir=/etc                \
        --localstatedir=/var             \
        --libdir=/usr/lib                \
        --sbindir=/usr/bin               \
        --without-manpages               \
        --with-shared                    \
        --without-normal                 \
        --disable-stripping              \
        --host=${TARGET_MACHINE_TRIPLET} \
        --build=${BUILD_MACHINE_TRIPLET} \
        --without-debug                  \
        --enable-pc-files                \
        --disable-setuid-environ         \
        --disable-root-environ           \
        --disable-root-access            \
        --with-versioned-syms            \
        --without-ada                    \
        --enable-overwrite               \
        --with-build-cc=gcc              \
        --with-pkg-config-libdir=/usr/lib/pkgconfig

    make -j 32
    make -j 32 DESTDIR="$LFS" install

    cd ..

    mkdir -vp build-widec-$TARGET_MACHINE_TRIPLET
    cd        build-widec-$TARGET_MACHINE_TRIPLET

    # --with-cxx-binding no c++?
    # --with-cxx-shared no c++?
    # --without-normal will make readline error
    # --disable-stripping  # this must go away
    "../configure"                       \
        --prefix=/usr                    \
        --sysconfdir=/etc                \
        --localstatedir=/var             \
        --libdir=/usr/lib                \
        --sbindir=/usr/bin               \
        --mandir=/usr/share/man          \
        --with-manpage-format=normal     \
        --with-shared                    \
        --without-normal                 \
        --disable-stripping              \
        --host=${TARGET_MACHINE_TRIPLET} \
        --build=${BUILD_MACHINE_TRIPLET} \
        --without-debug                  \
        --enable-pc-files                \
        --enable-widec                   \
        --disable-setuid-environ         \
        --disable-root-environ           \
        --disable-root-access            \
        --with-versioned-syms            \
        --without-ada                    \
        --enable-overwrite               \
        --with-build-cc=gcc              \
        --with-pkg-config-libdir=/usr/lib/pkgconfig

    make -j 32
    make -j 32 DESTDIR="$LFS" install

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/ncurses"
    touch "$STEPS_DIR/ncurses"
fi

# build readline (depends on libncurses)
if [ ! -f "$STEPS_DIR/readline" ]; then
    if [ ! -d "$TMP_BUILD_DIR/readline" ]; then
        tar -xf "$BASE_DIR/sources/readline-8.2.13.tar.gz"
        mv "readline-8.2.13" "$TMP_BUILD_DIR/readline"
    fi
    cd "$TMP_BUILD_DIR/readline"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    "../configure"                       \
        --host=${TARGET_MACHINE_TRIPLET} \
        --build=${BUILD_MACHINE_TRIPLET} \
        --prefix=/usr                    \
        --with-curses                    \
        --enable-static=no               \
        --cache-file=config.cache

    make -j 32 SHLIB_LIBS=-lncurses
    make -j 32 DESTDIR=$LFS install

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/readline"
    touch "$STEPS_DIR/readline"
fi

# build bash
if [ ! -f "$STEPS_DIR/bash" ]; then
    if [ ! -d "$TMP_BUILD_DIR/bash" ]; then
        tar -xzf "$BASE_DIR/sources/bash-5.2.tar.gz"
        mv "bash-5.2" "$TMP_BUILD_DIR/bash"
    fi
    cd "$TMP_BUILD_DIR/bash"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    _bashconfig=(-DDEFAULT_PATH_VALUE=\'\"/usr/local/sbin:/usr/local/bin:/usr/bin\"\'
               -DSTANDARD_UTILS_PATH=\'\"/usr/bin\"\'
               -DSYS_BASHRC=\'\"/etc/bash.bashrc\"\'
               -DSYS_BASH_LOGOUT=\'\"/etc/bash.bash_logout\"\'
               -DNON_INTERACTIVE_LOGIN_SHELLS)
    export CFLAGS_old="$CFLAGS"
    export CFLAGS="${CFLAGS} ${_bashconfig[@]}"

    "../configure"                       \
        --prefix=/usr                    \
        --host=${TARGET_MACHINE_TRIPLET} \
        --build=${BUILD_MACHINE_TRIPLET} \
        --without-bash-malloc            \
        --enable-threads                 \
        --enable-readline                \
        --with-curses

    make -j 32
    make -j 32 DESTDIR="$LFS" install

    export CFLAGS="$CFLAGS_old"

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/bash"
    touch "$STEPS_DIR/bash"
fi

# build bzip2
if [ ! -f "$STEPS_DIR/bzip2" ]; then
    if [ ! -d "$TMP_BUILD_DIR/bzip2" ]; then
        tar -xzf "$BASE_DIR/sources/bzip2-1.0.8.tar.gz"
        mv "bzip2-1.0.8" "$TMP_BUILD_DIR/bzip2"
    fi
    cd "$TMP_BUILD_DIR/bzip2"

    make CC="${CC} ${CFLAGS}" AR="${AR}" RANLIB="${RANLIB}" LD="${LD} ${LDFLAGS}" -j 32  PREFIX="$LFS/usr" install

    if [ -f "$LFS/bin/bzip2" ]; then
        "$TARGET_MACHINE_TRIPLET-strip" --strip-unneeded "$LFS/bin/bzip2"
    else
        echo "Where is the bzip2 executable? It was there for bash 1.0.8!"
        exit 1
    fi

    # Remove useless doc out of dir
    rm -rf "$LFS/man"

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/bzip2"
    touch "$STEPS_DIR/bzip2"
fi

# build check
if [ ! -f "$STEPS_DIR/check" ]; then
    if [ ! -d "$TMP_BUILD_DIR/check" ]; then
        tar -xzf "$BASE_DIR/sources/check-0.15.2.tar.gz"
        mv "check-0.15.2" "$TMP_BUILD_DIR/check"
    fi
    cd "$TMP_BUILD_DIR/check"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    "../configure"                       \
        --prefix=/usr                    \
        --host=${TARGET_MACHINE_TRIPLET} \
        --build=${BUILD_MACHINE_TRIPLET} \
        --libdir=/lib

    make -j 32
    make -j 32 DESTDIR="$LFS" install

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/check"
    touch "$STEPS_DIR/check"
fi

# build coreutils
if [ ! -f "$STEPS_DIR/coreutils" ]; then
    if [ ! -d "$TMP_BUILD_DIR/coreutils" ]; then
        tar -xzf "$BASE_DIR/sources/coreutils-9.5.tar.gz"
        mv "coreutils-9.5" "$TMP_BUILD_DIR/coreutils"
    fi
    cd "$TMP_BUILD_DIR/coreutils"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    "../configure"                        \
        --prefix=/usr                     \
        --libexecdir=/usr/lib             \
        --host=${TARGET_MACHINE_TRIPLET}                 \
        --build=${BUILD_MACHINE_TRIPLET}  \
        --enable-install-program=hostname \
        --cache-file=config.cache

    make -j 32
    make -j 32 DESTDIR="$LFS" install

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/coreutils"
    touch "$STEPS_DIR/coreutils"
fi

# build diffutils
if [ ! -f "$STEPS_DIR/diffutils" ]; then
    if [ ! -d "$TMP_BUILD_DIR/diffutils" ]; then
        tar -xf "$BASE_DIR/sources/diffutils-3.10.tar.xz"
        mv "diffutils-3.10" "$TMP_BUILD_DIR/diffutils"
    fi
    cd "$TMP_BUILD_DIR/diffutils"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    "../configure"                        \
        --prefix=$LFS                     \
        --host=${TARGET_MACHINE_TRIPLET}                 \
        --build=${BUILD_MACHINE_TRIPLET}  \
        --enable-install-program=hostname \
        --cache-file=config.cache

    make -j 32
    make -j 32 install

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/diffutils"
    touch "$STEPS_DIR/diffutils"
fi

# build libseccomp
if [ ! -f "$STEPS_DIR/libseccomp" ]; then
    if [ ! -d "$TMP_BUILD_DIR/libseccomp" ]; then
        tar -xf "$BASE_DIR/sources/libseccomp-2.5.5.tar.gz"
        mv "libseccomp-2.5.5" "$TMP_BUILD_DIR/libseccomp"
    fi
    cd "$TMP_BUILD_DIR/libseccomp"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    "../configure"                        \
        --prefix=/usr                     \
        --host=${TARGET_MACHINE_TRIPLET}                 \
        --build=${BUILD_MACHINE_TRIPLET}  \
        --enable-static=no                \
        --cache-file=config.cache

    make -j 32
    make -j 32 DESTDIR="$LFS" install

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/libseccomp"
    touch "$STEPS_DIR/libseccomp"
fi

# build file
if [ ! -f "$STEPS_DIR/file" ]; then
    if [ ! -d "$TMP_BUILD_DIR/file" ]; then
        tar -xf "$BASE_DIR/sources/file-5.46.tar.gz"
        mv "file-5.46" "$TMP_BUILD_DIR/file"
    fi
    cd "$TMP_BUILD_DIR/file"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    "../configure"                        \
        --prefix=/usr                     \
        --libdir=/usr/lib                 \
        --datadir=/usr/share/file         \
        --with-sysroot=$LFS               \
        --host=${TARGET_MACHINE_TRIPLET}                 \
        --build=${BUILD_MACHINE_TRIPLET}  \
        --enable-libseccomp               \
        --cache-file=config.cache

    make -j 32
    make -j 32 DESTDIR="$LFS" install

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/file"
    touch "$STEPS_DIR/file"
fi

# build findutils
if [ ! -f "$STEPS_DIR/findutils" ]; then
    if [ ! -d "$TMP_BUILD_DIR/findutils" ]; then
        tar -xf "$BASE_DIR/sources/findutils-4.10.0.tar.xz"
        mv "findutils-4.10.0" "$TMP_BUILD_DIR/findutils"
    fi
    cd "$TMP_BUILD_DIR/findutils"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    echo "gl_cv_func_wcwidth_works=yes" > config.cache
    echo "ac_cv_func_fnmatch_gnu=yes" >> config.cache

    "../configure"                        \
        --prefix=/usr                     \
        --host=${TARGET_MACHINE_TRIPLET}                 \
        --build=${BUILD_MACHINE_TRIPLET}  \
        --cache-file=config.cache

    make -j 32
    make -j 32 DESTDIR="$LFS" install

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/findutils"
    touch "$STEPS_DIR/findutils"
fi

# build gawk
if [ ! -f "$STEPS_DIR/gawk" ]; then
    if [ ! -d "$TMP_BUILD_DIR/gawk" ]; then
        tar -xf "$BASE_DIR/sources/gawk-5.3.1.tar.xz"
        mv "gawk-5.3.1" "$TMP_BUILD_DIR/gawk"
    fi
    cd "$TMP_BUILD_DIR/gawk"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    "../configure"                       \
        --prefix=/usr                    \
        --libexecdir=/usr/lib            \
        --sysconfdir=/etc                \
        --host=${TARGET_MACHINE_TRIPLET} \
        --build=${BUILD_MACHINE_TRIPLET} \
        --without-libsigsegv             \
        --cache-file=config.cache

    make -j 32
    make -j 32 DESTDIR="$LFS" install
    
    "$STRIP" --strip-unneeded "$LFS/bin/gawk"

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/gawk"
    touch "$STEPS_DIR/gawk"
fi

# build grep
if [ ! -f "$STEPS_DIR/grep" ]; then
    if [ ! -d "$TMP_BUILD_DIR/grep" ]; then
        tar -xf "$BASE_DIR/sources/grep-3.11.tar.xz"
        mv "grep-3.11" "$TMP_BUILD_DIR/grep"
    fi
    cd "$TMP_BUILD_DIR/grep"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    "../configure"                       \
        --prefix=/usr                    \
        --host=${TARGET_MACHINE_TRIPLET} \
        --build=${BUILD_MACHINE_TRIPLET} \
        --without-included-regex         \
        --cache-file=config.cache

    make -j 32
    make -j 32 DESTDIR="$LFS" install

    "$STRIP" --strip-unneeded "$LFS/bin/grep"

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/grep"
    touch "$STEPS_DIR/grep"
fi

# build gzip
if [ ! -f "$STEPS_DIR/gzip" ]; then
    if [ ! -d "$TMP_BUILD_DIR/gzip" ]; then
        tar -xf "$BASE_DIR/sources/gzip-1.13.tar.xz"
        mv "gzip-1.13" "$TMP_BUILD_DIR/gzip"
    fi
    cd "$TMP_BUILD_DIR/gzip"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    "../configure"                       \
        --prefix=$LFS                    \
        --host=${TARGET_MACHINE_TRIPLET} \
        --build=${BUILD_MACHINE_TRIPLET} \
        --cache-file=config.cache

    make -j 32
    make -j 32 install

    "$STRIP" --strip-unneeded "$LFS/bin/gzip"

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/gzip"
    touch "$STEPS_DIR/gzip"
fi

# build make
if [ ! -f "$STEPS_DIR/make" ]; then
    if [ ! -d "$TMP_BUILD_DIR/make" ]; then
        tar -xf "$BASE_DIR/sources/make-4.4.1.tar.gz"
        mv "make-4.4.1" "$TMP_BUILD_DIR/make"
    fi
    cd "$TMP_BUILD_DIR/make"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    "../configure"                       \
        --prefix=/usr                    \
        --host=${TARGET_MACHINE_TRIPLET} \
        --build=${BUILD_MACHINE_TRIPLET} \
        --cache-file=config.cache

    make -j 32
    make -j 32 DESTDIR="$LFS" install

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/make"
    touch "$STEPS_DIR/make"
fi

# build libiconv
if [ ! -f "$STEPS_DIR/libiconv" ]; then
    if [ ! -d "$TMP_BUILD_DIR/libiconv" ]; then
        tar -xf "$BASE_DIR/sources/libiconv-1.17.tar.gz"
        mv "libiconv-1.17" "$TMP_BUILD_DIR/libiconv"
    fi
    cd "$TMP_BUILD_DIR/libiconv"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    "../configure"                       \
        --prefix=/usr                    \
        --host=${TARGET_MACHINE_TRIPLET} \
        --build=${BUILD_MACHINE_TRIPLET} \
        --enable-extra-encodings         \
        --cache-file=config.cache

    # workaround for insecure rpath
    sed -i 's|^hardcode_libdir_flag_spec=.*|hardcode_libdir_flag_spec=""|g' libtool
    sed -i 's|^runpath_var=LD_RUN_PATH|runpath_var=DIE_RPATH_DIE|g' libtool

    make -j 32
    make -j 32 DESTDIR="$LFS" install

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/libiconv"
    touch "$STEPS_DIR/libiconv"
fi

# build patch
if [ ! -f "$STEPS_DIR/patch" ]; then
    if [ ! -d "$TMP_BUILD_DIR/patch" ]; then
        tar -xf "$BASE_DIR/sources/patch-2.7.6.tar.gz"
        mv "patch-2.7.6" "$TMP_BUILD_DIR/patch"
    fi
    cd "$TMP_BUILD_DIR/patch"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    "../configure"                       \
        --prefix=/usr                    \
        --host=${TARGET_MACHINE_TRIPLET} \
        --build=${BUILD_MACHINE_TRIPLET} \
        --cache-file=config.cache

    make -j 32
    make -j 32 DESTDIR="$LFS" install

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/patch"
    touch "$STEPS_DIR/patch"
fi

# build sed
if [ ! -f "$STEPS_DIR/sed" ]; then
    if [ ! -d "$TMP_BUILD_DIR/sed" ]; then
        tar -xf "$BASE_DIR/sources/sed-4.9.tar.xz"
        mv "sed-4.9" "$TMP_BUILD_DIR/sed"
    fi
    cd "$TMP_BUILD_DIR/sed"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    "../configure"                       \
        --prefix=/usr                    \
        --host=${TARGET_MACHINE_TRIPLET} \
        --build=${BUILD_MACHINE_TRIPLET} \
        --cache-file=config.cache

    make -j 32
    make -j 32 DESTDIR="$LFS" install

    "$TARGET_MACHINE_TRIPLET-strip" --strip-unneeded "$LFS/bin/sed"

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/sed"
    touch "$STEPS_DIR/sed"
fi

# build tar
if [ ! -f "$STEPS_DIR/tar" ]; then
    if [ ! -d "$TMP_BUILD_DIR/tar" ]; then
        tar -xf "$BASE_DIR/sources/tar-1.35.tar.xz"
        mv "tar-1.35" "$TMP_BUILD_DIR/tar"
    fi
    cd "$TMP_BUILD_DIR/tar"

    export LDFLAGS_old="$LDFLAGS"
    export LDFLAGS="$LDFLAGS -liconv"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

#    cat > config.cache << EOF
#gl_cv_func_wcwidth_works=yes
#gl_cv_func_btowc_eof=yes
#ac_cv_func_malloc_0_nonnull=yes
#gl_cv_func_mbrtowc_incomplete_state=yes
#gl_cv_func_mbrtowc_nul_retval=yes
#gl_cv_func_mbrtowc_null_arg1=yes
#gl_cv_func_mbrtowc_null_arg2=yes
#gl_cv_func_mbrtowc_retval=yes
#gl_cv_func_wcrtomb_retval=yes
#EOF

    "../configure"                       \
        --prefix=/usr                    \
        --sbindir=/usr/bin               \
        --libexecdir=/usr/lib/tar        \
        --host=${TARGET_MACHINE_TRIPLET} \
        --build=${BUILD_MACHINE_TRIPLET} \
        --enable-backup-scripts          \
        --cache-file=config.cache

    make -j 32
    make -j 32 DESTDIR="$LFS" install

    "$TARGET_MACHINE_TRIPLET-strip" --strip-unneeded "$LFS/bin/tar"

    export LDFLAGS="$LDFLAGS_old"

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/tar"
    touch "$STEPS_DIR/tar"
fi

## build the rest of gcc
#if [ ! -f "$STEPS_DIR/gcc-final" ]; then
#    bash unpack-gcc.sh "$TMP_BUILD_DIR/"
#    cd "$TMP_BUILD_DIR/gcc/"
#    
#    mkdir -vp build-$TARGET_MACHINE_TRIPLET
#    cd        build-$TARGET_MACHINE_TRIPLET
#
#    "../configure"                       \
#        --target=$TARGET_MACHINE_TRIPLET \
#        --host=${BUILD_MACHINE_TRIPLET}  \
#        --build=${TARGET_MACHINE_TRIPLET}               \
#        --prefix=$LFS                    \
#        --with-glibc-version=2.40        \
#        --with-sysroot=$LFS              \
#        --enable-c99                     \
#        --enable-long-long               \
#        --enable-default-pie             \
#        --enable-default-ssp             \
#        --disable-nls                    \
#        --disable-multilib               \
#        --disable-libgomp                \
#        --disable-libquadmath            \
#        --disable-libquadmath-support    \
#        --disable-decimal-float          \
#        --enable-languages=c,c++
#
#    # Reebuild everything now that we have bootstrapped an initial gcc and glibc 
#    make -j 32 # if build fails add --disable-libsanitizer
#    make -j 32 install
#
#    cd "$BASE_DIR"
#    rm -rf "$TMP_BUILD_DIR/gcc"
#    touch "$STEPS_DIR/gcc-step3"
#fi
#exit 0

# build xz-utils
if [ ! -f "$STEPS_DIR/xz" ]; then
    if [ ! -d "$TMP_BUILD_DIR/xz" ]; then
        tar -xf "$BASE_DIR/sources/xz-5.6.3.tar.xz"
        mv "xz-5.6.3" "$TMP_BUILD_DIR/xz"
    fi
    cd "$TMP_BUILD_DIR/xz"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    "../configure"                       \
        --prefix=/usr                    \
        --host=${TARGET_MACHINE_TRIPLET} \
        --build=${BUILD_MACHINE_TRIPLET} \
        --disable-static                 \
        --cache-file=config.cache

    make -j 32
    make -j 32 DESTDIR=$LFS install

    # Remove the libtool archive file because it is harmful for cross compilation
    #rm -v $LFS/usr/lib/liblzma.la

    "$TARGET_MACHINE_TRIPLET-strip" --strip-unneeded "$LFS/bin/xz"
    "$TARGET_MACHINE_TRIPLET-strip" --strip-unneeded "$LFS/bin/xzdec"
    "$TARGET_MACHINE_TRIPLET-strip" --strip-unneeded "$LFS/bin/xzcat"

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/xz"
    touch "$STEPS_DIR/xz"
fi

# build gettext
if [ ! -f "$STEPS_DIR/gettext" ]; then
    if [ ! -d "$TMP_BUILD_DIR/gettext" ]; then
        tar -xf "$BASE_DIR/sources/gettext-0.23.tar.gz"
        mv "gettext-0.23" "$TMP_BUILD_DIR/gettext"
    fi
    cd "$TMP_BUILD_DIR/gettext"

    #EMACS="no" autoreconf -fi

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    EMACS="no" "../configure"             \
        --prefix=/usr                     \
        --host=${TARGET_MACHINE_TRIPLET}                 \
        --build=${BUILD_MACHINE_TRIPLET}  \
        --disable-shared                  \
        --libdir=/usr/lib                 \
        --with-sysroot=$SYSROOT           \
        --enable-nls                      \
        --enable-curses                   \
        --with-xz                         \
        --cache-file=config.cache

    make -j 32
    make -j 32 DESTDIR="$LFS" install

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/gettext"
    touch "$STEPS_DIR/gettext"
fi

# build acl
if [ ! -f "$STEPS_DIR/acl" ]; then
    if [ ! -d "$TMP_BUILD_DIR/acl" ]; then
        tar -xf "$BASE_DIR/sources/acl-2.3.2.tar.xz"
        mv "acl-2.3.2" "$TMP_BUILD_DIR/acl"
    fi
    cd "$TMP_BUILD_DIR/acl"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    "../configure"                       \
        --prefix=/usr                    \
        --libexecdir=/usr/lib            \
        --libdir=/usr/lib                \
        --with-sysroot=${LFS}            \
        --host=${TARGET_MACHINE_TRIPLET} \
        --build=${BUILD_MACHINE_TRIPLET} \
        --disable-static                 \
        --cache-file=config.cache

    make -j 32
    make -j 32 DESTDIR=$LFS install

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/acl"
    touch "$STEPS_DIR/acl"
fi

# build pcre2
if [ ! -f "$STEPS_DIR/pcre2" ]; then
    if [ ! -d "$TMP_BUILD_DIR/pcre2" ]; then
        tar -xf "$BASE_DIR/sources/pcre2-10.44.tar.bz2"
        mv "pcre2-10.44" "$TMP_BUILD_DIR/pcre2"
    fi
    cd "$TMP_BUILD_DIR/pcre2"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    export CFLAGS_old="$CFLAGS"
    export CXXFLAGS_old="$CXXFLAGS"
    # use fat LTO objects for static libraries
    CFLAGS+=" -ffat-lto-objects"
    CXXFLAGS+=" -ffat-lto-objects"

    # WARNING: using prefix with LFS is a VERY BIG WORKAROUND!!!
    "../configure"                       \
        --with-sysroot=${LFS}            \
        --host=${TARGET_MACHINE_TRIPLET} \
        --build=${BUILD_MACHINE_TRIPLET} \
        --prefix=${LFS}/usr              \
        --enable-shared                  \
        --enable-static=no               \
        --enable-jit                     \
        --enable-pcre2-16                \
        --enable-pcre2-32                \
        --enable-pcre2grep-libbz2        \
        --enable-pcre2grep-libz          \
        --enable-pcre2test-libreadline   \
        --cache-file=config.cache

    make -j 32
    make -j 32 install

    export CFLAGS="$CFLAGS_old"
    export CXXFLAGS="$CXXFLAGS_old"

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/pcre2"
    touch "$STEPS_DIR/pcre2"
fi

# build swig
if [ ! -f "$STEPS_DIR/swig" ]; then
    if [ ! -d "$TMP_BUILD_DIR/swig" ]; then
        tar -xf "$BASE_DIR/sources/swig-4.3.0.tar.gz"
        mv "swig-4.3.0" "$TMP_BUILD_DIR/swig"
    fi
    cd "$TMP_BUILD_DIR/swig"

    "./autogen.sh"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    "../configure"                       \
        --with-sysroot=${LFS}            \
        --host=${TARGET_MACHINE_TRIPLET} \
        --build=${BUILD_MACHINE_TRIPLET} \
        --prefix=/usr                    \
        --cache-file=config.cache

    make -j 32
    make -j 32 DESTDIR="$LFS" install

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/swig"
    touch "$STEPS_DIR/swig"
fi

# build libcap-ng (needs swig)
if [ ! -f "$STEPS_DIR/libcap-ng" ]; then
    if [ ! -d "$TMP_BUILD_DIR/libcap-ng" ]; then
        tar -xf "$BASE_DIR/sources/libcap-ng-0.8.5.tar.gz"
        mv "libcap-ng-0.8.5" "$TMP_BUILD_DIR/libcap-ng"
    fi
    cd "$TMP_BUILD_DIR/libcap-ng"

    # this workaround comes straight from archlinux
    # make stupid autotools happy -_-
    touch NEWS

    autoreconf -fiv

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    # --enable-zos-remote requires libldap
    "../configure"                       \
        --with-sysroot=${LFS}            \
        --host=${TARGET_MACHINE_TRIPLET} \
        --build=${BUILD_MACHINE_TRIPLET} \
        --prefix=/usr                    \
        --without-python                 \
        --without-python3                \
        --enable-static=no               \
        --cache-file=config.cache

    make -j 32
    make -j 32 DESTDIR=$LFS install

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/libcap-ng"
    touch "$STEPS_DIR/libcap-ng"
fi

# build audit
if [ ! -f "$STEPS_DIR/audit-userspace" ]; then
    if [ ! -d "$TMP_BUILD_DIR/audit-userspace" ]; then
        tar -xf "$BASE_DIR/sources/audit-userspace-4.0.2.tar.gz"
        mv "audit-userspace-4.0.2" "$TMP_BUILD_DIR/audit-userspace"
    fi
    cd "$TMP_BUILD_DIR/audit-userspace"

    autoreconf -fiv

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

    # --with-arm
    # --enable-zos-remote requires libldap
    "../configure"                       \
        --with-sysroot=${LFS}            \
        --host=${TARGET_MACHINE_TRIPLET} \
        --build=${BUILD_MACHINE_TRIPLET} \
        --enable-gssapi-krb5=no          \
        --enable-systemd=no              \
        --disable-zos-remote             \
        --libexecdir=/usr/lib/audit      \
        --prefix=/usr                    \
        --runstatedir=/run               \
        --sbindir=/usr/bin               \
        --sysconfdir=/etc                \
        --with-apparmor=no               \
        --with-io_uring=yes              \
        --with-libcap-ng=yes             \
        --with-python3=no                \
        --disable-static                 \
        --cache-file=config.cache

    make -j 32
    make -j 32 DESTDIR=$LFS install

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/audit-userspace"
    touch "$STEPS_DIR/audit-userspace"
fi

for f in "$LFS"/usr/bin/*; do
    if "$READELF" -h $f | grep -Fq "Executable"; then
        echo "Stripping $f..."
        "$STRIP" -s "$f"
    fi
done

# Postpone texinfo
exit 0

# build texinfo
if [ ! -f "$STEPS_DIR/texinfo" ]; then
    if [ ! -d "$TMP_BUILD_DIR/texinfo" ]; then
        tar -xf "$BASE_DIR/sources/texinfo-7.1.1.tar.xz"
        mv "texinfo-7.1.1" "$TMP_BUILD_DIR/texinfo"
    fi
    cd "$TMP_BUILD_DIR/texinfo"

    mkdir -vp build-$TARGET_MACHINE_TRIPLET
    cd        build-$TARGET_MACHINE_TRIPLET

#    cat > config.cache << EOF
#gl_replace_getopt=no
#am_func_iconv=no
#ac_cv_func_calloc_0_nonnull=no
#gl_cv_func_getopt_posix=no
#ac_fn_c_try_run=no
#EOF

    PERL=/usr/bin/perl                      \
    "../configure"                          \
        --prefix=/usr                       \
        --host=${TARGET_MACHINE_TRIPLET}                   \
        --build=${BUILD_MACHINE_TRIPLET}    \
        --enable-cross-guesses=conservative \
        --enable-year2038                   \
        --cache-file=config.cache

    #make -j 32
    #make -j 32 DESTDIR="$LFS" install

    cd "$BASE_DIR"
    rm -rf "$TMP_BUILD_DIR/texinfo"
    touch "$STEPS_DIR/texinfo"
fi



#"$TARGET_MACHINE_TRIPLET-strip" --strip-unneeded $LFS/bin/*

# build libcap2
#if [ ! -f "$STEPS_DIR/libcap2" ]; then
#    if [ ! -d "$TMP_BUILD_DIR/libcap2" ]; then
#        tar -xzf "$BASE_DIR/sources/libcap-2.73.tar.gz"
#        mv "libcap2" "$TMP_BUILD_DIR/libcap2"
#    fi
#    cd "$TMP_BUILD_DIR/libcap2"
#
#    mkdir -vp build
#    cd        build
#
#    echo "rootsbindir=/usr/sbin" > configparms
#
#    "../configure"                        \
#        --prefix=/usr                     \
#        --disable-static                  \
#        --target=$TARGET_MACHINE_TRIPLET                 \
#        --host=$(build-aux/config.guess)  \
#        --build=$(build-aux/config.guess) \
#
#    make -j 32
#    make DESTDIR=$LFS install
#
#    cd "$BASE_DIR"
#
#    touch "$STEPS_DIR/libcap2"
#fi

# Remove man pages: totally useless
rm -rf "$LFS"/usr/share/man
rm -rf "$LFS"/man

# Right now I have no idea if g++ will build crap.