diff options
Diffstat (limited to 'include/tree.sh')
| -rw-r--r-- | include/tree.sh | 744 |
1 files changed, 586 insertions, 158 deletions
diff --git a/include/tree.sh b/include/tree.sh index 4d0c533d..166a3d86 100644 --- a/include/tree.sh +++ b/include/tree.sh @@ -1,103 +1,211 @@ # SPDX-License-Identifier: GPL-3.0-or-later + # Copyright (c) 2022-2023 Alper Nebi Yasak <alpernebiyasak@gmail.com> # Copyright (c) 2022 Ferass El Hafidi <vitali64pmemail@protonmail.com> # Copyright (c) 2023-2025 Leah Rowe <leah@libreboot.org> -eval "`setvars "" xarch srcdir premake gnatdir xlang mode makeargs elfdir cmd \ - project target target_dir targets xtree _f release bootstrapargs mkhelper \ - autoconfargs listfile autogenargs btype rev build_depend gccdir cmakedir \ - defconfig postmake mkhelpercfg dry dest_dir mdir cleanargs gccver gccfull \ - gnatver gnatfull do_make badhash tree`" +# flag e.g. ./mk -b <-- mkflag would be "b" +flag="" + +# macros, overridden depending on the flag +if_do_make="" +if_dry_build=":" +if_not_do_make=":" +if_not_dry_build="" + +autoconfargs="" +autogenargs="" +badhash="" +badtghash="" +bootstrapargs="" +build_depend="" +buildtype="" +cleanargs="" +cmakedir="" +cmd="" +defconfig="" +dest_dir="" +elfdir="" +forcepull="" +gccdir="" +gccfull="" +gccver="" +gnatdir="" +gnatfull="" +gnatver="" +listfile="" +makeargs="" +mdir="" +mkhelper="" +mkhelpercfg="" +mode="" +postmake="" +premake="" +project="" +release="" +rev="" +srcdir="" +target="" +target_dir="" +targets="" +tree="" +xarch="" +xgcctree="" +xlang="" trees() { - flags="f:b:m:u:c:x:s:l:n:d:" + flags="f:F:b:m:u:c:x:s:l:n:d:" + + while getopts $flags option + do + if [ -n "$flag" ]; then + err "only one flag is permitted" "trees" "$@" + fi - while getopts $flags option; do - [ -n "$_f" ] && err "only one flag is permitted" - _f="$1" + flag="$1" - case "$_f" in - -d) dry=":" ;; + # the "mode" variable is affixed to a make command, example: + # ./mk -m coreboot does: make menuconfig -C src/coreboot/tree + + case "$flag" in + -d) + # -d is similar to -b, except that + # a large number of operations will be + # skipped. these are "if_not_dry_build build" scenarios + # where only a subset of build tasks are done, + # and $if_not_dry_build is prefixed to skipped commands + + if_dry_build="" + if_not_dry_build=":" + ;; -b) : ;; -u) mode="oldconfig" ;; -m) mode="menuconfig" ;; -c) mode="distclean" ;; -x) mode="crossgcc-clean" ;; - -f) - do_make="n" - dry=":" ;; + -f|-F) # download source code for a project + # macros. colon means false. + if_do_make=":" + if_dry_build="" + if_not_do_make="" + if_not_dry_build=":" + if [ "$flag" = "-F" ]; then + # don't skip git fetch/pull on cached src + + forcepull="y" + fi + ;; -s) mode="savedefconfig" ;; -l) mode="olddefconfig" ;; -n) mode="nconfig" ;; - *) err "invalid option '-$option'" ;; + *) err "invalid option '-$option'" "trees" "$@" ;; esac if [ -z "${OPTARG+x}" ]; then shift 1 + break fi project="${OPTARG#src/}" + project="${project#config/git/}" + shift 2 done - [ -z "$_f" ] && err "missing flag ($flags)" - if [ -z "$project" ]; then - mk $_f $(ls -1 config/git) + + if [ -z "$flag" ]; then + err "missing flag ($flags)" "trees" "$@" + elif [ -z "$project" ]; then + fx_ "x_ ./mk $flag" x_ ls -1 config/git + return 1 - fi - [ -f "config/git/$project/pkg.cfg" ] || \ - err "config/git/$project/pkg.cfg missing" + elif [ ! -f "config/git/$project/pkg.cfg" ]; then + err "config/git/$project/pkg.cfg missing" "trees" "$@" + fi - for d in "elf" "config/data" "config" "src"; do - eval "${d#*/}dir=\"$d/$project\"" - done + elfdir="elf/$project" + datadir="config/data/$project" + configdir="config/$project" + srcdir="src/$project" dest_dir="$elfdir" listfile="$datadir/build.list" - [ -f "$listfile" ] || listfile="" # optional on all projects + if [ ! -f "$listfile" ]; then + listfile="" # build.list is optional on all projects + fi mkhelpercfg="$datadir/mkhelper.cfg" if e "$mkhelpercfg" f missing; then - mkhelpercfg="$xbmktmp/mkhelper.cfg" + mkhelpercfg="$xbtmp/mkhelper.cfg" x_ touch "$mkhelpercfg" fi targets="$*" cmd="build_targets $targets" - singletree "$project" && cmd="build_project" + if singletree "$project"; then + cmd="build_project" + fi remkdir "${tmpgit%/*}" } build_project() { - configure_project "$configdir" || return 0 - [ ! -f "$listfile" ] || $dry elfcheck || return 0 + if ! configure_project "$configdir"; then + return 0 + elif [ -f "$listfile" ]; then + if ! $if_not_dry_build elfcheck; then + return 0 + fi + fi - [ "$mode" = "distclean" ] && mode="clean" - run_make_command || return 0 + if [ "$mode" = "distclean" ]; then + mode="clean" + fi - [ -n "$mode" ] || $dry copy_elf; : + if ! run_make_command; then + return 0 + fi + + if [ -z "$mode" ]; then + $if_not_dry_build \ + copy_elf; : + fi } build_targets() { - [ -d "$configdir" ] || err "directory, $configdir, does not exist" - [ $# -gt 0 ] || targets="$(ls -1 "$configdir")" || err "!o $configdir" + if [ ! -d "$configdir" ]; then + err "directory '$configdir' doesn't exist" "build_targets" "$@" + elif [ $# -lt 1 ]; then + targets="$(ls -1 "$configdir")" || \ + err "'$configdir': can't list targets" "build_targets" "$@" + fi - for x in $targets; do + for x in $targets + do unset CROSS_COMPILE export PATH="$xbmkpath" - [ "$x" = "list" ] && x_ ls -1 "config/$project" && \ - listfile="" && break + + if [ "$x" = "list" ]; then + x_ ls -1 "config/$project" + + listfile="" + + break + fi + + printf "'make %s', '%s', '%s'\n" "$mode" "$project" "$x" target="$x" - printf "'make %s', '%s', '%s'\n" "$mode" "$project" "$target" + x_ handle_defconfig - [ -n "$mode" ] || x_ $postmake + if [ -z "$mode" ]; then + x_ $postmake + fi done; : } @@ -105,158 +213,403 @@ handle_defconfig() { target_dir="$configdir/$target" - [ -f "CHANGELOG" ] || fetch_project "$project" - configure_project "$target_dir" || return 0 - x_ mkdir -p "$elfdir/$target" + if [ ! -f "CHANGELOG" ]; then + fetch_project "$project" + fi + if ! configure_project "$target_dir"; then + return 0 + fi + + if [ -z "$tree" ]; then + err "$configdir: 'tree' not set" "handle_defconfig" "$@" + fi - chkvars tree srcdir="src/$project/$tree" - if [ "$mode" = "distclean" ] || [ "$mode" = "crossgcc-clean" ]; then - [ -d "$srcdir" ] || return 0 + if [ "$mode" = "${mode%clean}" ] && [ ! -d "$srcdir" ]; then + return 0 fi - [ -z "$mode" ] && for _xarch in $xarch; do - $dry check_cross_compiler "$_xarch" - done; : - for y in "$target_dir/config"/*; do - [ "$_f" = "-d" ] || [ -f "$y" ] || continue - [ "$_f" = "-d" ] || defconfig="$y" + for y in "$target_dir/config"/* + do + if [ "$flag" != "-d" ] && [ ! -f "$y" ]; then + continue + elif [ "$flag" != "-d" ]; then + defconfig="$y" + fi + + if [ -z "$mode" ]; then + check_defconfig || continue; : + fi + + if [ -z "$mode" ]; then + for _xarch in $xarch; do + $if_dry_build \ + break + if [ -n "$_xarch" ]; then + check_cross_compiler "$_xarch" + fi + done; : + fi - [ -n "$mode" ] || check_defconfig || continue handle_makefile - [ -n "$mode" ] || $dry copy_elf + + if [ -z "$mode" ]; then + $if_not_dry_build \ + copy_elf + fi done; : } configure_project() { - eval "`setvars "" cleanargs build_depend autoconfargs xtree postmake \ - makeargs btype mkhelper bootstrapargs premake release xlang xarch \ - badhash`" _tcfg="$1/target.cfg" - [ -f "$_tcfg" ] || btype="auto" - e "$datadir/mkhelper.cfg" f && eval "`setcfg "$datadir/mkhelper.cfg"`" - while e "$_tcfg" f || [ "$cmd" != "build_project" ]; do - eval "`setvars "" rev tree`" - eval "`setcfg "$_tcfg"`" + autoconfargs="" + badhash="" + badtghash="" + bootstrapargs="" + build_depend="" + buildtype="" + cleanargs="" + makeargs="" + mkhelper="" + postmake="" + premake="" + release="" + xarch="" + xgcctree="" + xlang="" + + if [ ! -f "$_tcfg" ]; then + buildtype="auto" + fi + + # globally initialise all variables for a source tree / target: + + if e "$datadir/mkhelper.cfg" f; then + . "$datadir/mkhelper.cfg" || \ + err "Can't read '$datadir/mkhelper.cfg'" \ + "configure_project" "$@" + fi + + # override target/tree specific variables from per-target config: + + while e "$_tcfg" f || [ "$cmd" != "build_project" ] + do + # TODO: implement infinite loop detection here, caused + # by project targets pointing to other targets/trees + # when then ultimate point back repeatedly; this is + # currently avoided simply by careful configuration. + # temporary files per tree/target name could be created + # per iteration, and then checked the next time + printf "Loading %s config: %s\n" "$project" "$_tcfg" - [ "$_f" = "-d" ] && build_depend="" # dry run - [ "$cmd" = "build_project" ] && break - [ "$do_make" != "n" ] && break + rev="" + tree="" + + . "$_tcfg" || \ + err "Can't read '$_tcfg'" "configure_project" "$@" + + if [ "$flag" = "-d" ]; then + build_depend="" # dry run + fi + if [ "$cmd" = "build_project" ]; then + # single-tree, so it can't be a target pointing + # to a main source tree + + break + fi + $if_do_make \ + break + if [ "${_tcfg%/*/target.cfg}" = "${_tcfg%"/$tree/target.cfg"}" ] + then + # we have found the main source tree that + # a given target uses; no need to continue + + break + else + _tcfg="${_tcfg%/*/target.cfg}/$tree/target.cfg" + fi - [ "${_tcfg%/*/target.cfg}" = "${_tcfg%"/$tree/target.cfg"}" ] \ - && break - _tcfg="${_tcfg%/*/target.cfg}/$tree/target.cfg" done - [ "$XBMK_RELEASE" = "y" ] && [ "$release" = "n" ] && return 1 - [ -z "$btype" ] || [ "${mode%config}" = "$mode" ] || return 1 - [ -z "$mode" ] && $dry build_dependencies + + if [ "$XBMK_RELEASE" = "y" ] && [ "$release" = "n" ]; then + return 1 + fi + if [ -n "$buildtype" ] && [ "${mode%config}" != "$mode" ]; then + return 1 + fi + + if [ -z "$mode" ]; then + $if_not_dry_build \ + build_dependencies + fi mdir="$xbmkpwd/config/submodule/$project" - [ -n "$tree" ] && mdir="$mdir/$tree" - [ -f "CHANGELOG" ] || check_project_hashes + if [ -n "$tree" ]; then + mdir="$mdir/$tree" + fi - if [ "$do_make" = "n" ]; then - [ -f "CHANGELOG" ] || fetch_${cmd#build_} - return 1 + if [ ! -f "CHANGELOG" ]; then + delete_old_project_files + $if_not_do_make \ + fetch_${cmd#build_} fi + $if_not_do_make \ + return 1 + x_ ./mk -f "$project" "$target" } +# projects can specify which other projects +# to build first, as declared dependencies: + build_dependencies() { - for bd in $build_depend; do - bd_p="${bd%%/*}" - bd_t="${bd##*/}" - [ -z "$bd_p" ] && $dry err "$project/$tree: !bd '$bd'" - [ "${bd##*/}" = "$bd" ] && bd_t="" - [ -z "$bd_p" ] || $dry x_ ./mk -b $bd_p $bd_t; : + for bd in $build_depend + do + bd_project="${bd%%/*}" + bd_tree="${bd##*/}" + + if [ -z "$bd_project" ]; then + $if_not_dry_build \ + err "$project/$tree: !bd '$bd'" \ + "build_dependencies" "$@" + fi + if [ "${bd##*/}" = "$bd" ]; then + bd_tree="" + fi + if [ -n "$bd_project" ]; then + $if_not_dry_build \ + x_ ./mk -b $bd_project $bd_tree; : + fi done; : } -check_project_hashes() +# delete_old_project_files along with project_up_to_date, +# concatenates the sha512sum hashes of all files related to +# a project, tree or target, then gets the sha512sum of that +# concatenation. this is checked against any existing +# calculation previously cached; if the result differs, or +# nothing was previously stored, we know to delete resources +# such as builds, project sources and so on, for auto-rebuild: + +delete_old_project_files() +{ + # delete an entire source tree along with its builds: + if ! project_up_to_date hash "$tree" badhash "$datadir" \ + "$configdir/$tree" "$mdir"; then + x_ rm -Rf "src/$project/$tree" "elf/$project/$tree" + fi + + x_ cp "$xbtmp/new.hash" "$XBMK_CACHE/hash/$project$tree" + + if singletree "$project" || [ -z "$target" ] || [ "$target" = "$tree" ] + then + return 0 + fi + + # delete only the builds of a given target, but not src. + # this is useful when only the target config changes, for + # example x200_8mb coreboot configs change, but not coreboot: + + if ! project_up_to_date tghash "$target" badtghash "$configdir/$target" + then + x_ rm -Rf "elf/$project/$tree/$target" + fi + + x_ cp "$xbtmp/new.hash" "$XBMK_CACHE/tghash/$project$target" +} + +project_up_to_date() { - old_pjhash="" && x_ mkdir -p "$XBMK_CACHE/hash" - [ ! -f "$XBMK_CACHE/hash/$project$tree" ] || \ - read -r old_pjhash < "$XBMK_CACHE/hash/$project$tree" + old_hash="" + hash="" + + hashdir="$1" + hashname="$2" + badhashvar="$3" + + shift 3 + + x_ xbmkdir "$XBMK_CACHE/$hashdir" + + if [ -f "$XBMK_CACHE/$hashdir/$project$hashname" ]; then + read -r old_hash < "$XBMK_CACHE/$hashdir/$project$hashname" \ + || err \ + "$hashdir: err '$XBMK_CACHE/$hashdir/$project$hashname'" \ + "project_up_to_date" "$hashdir" "$hashname" "$badhashvar" \ + "$@" + fi + + build_sbase + fx_ "x_ util/sbase/sha512sum" find "$@" -type f -not -path \ + "*/.git*/*" | awk '{print $1}' > "$xbtmp/tmp.hash" || \ + err "!h $project $hashdir" \ + "project_up_to_date" "$hashdir" "$hashname" "$badhashvar" "$@" - fx_ "x_ sha512sum" find "$datadir" "$configdir/$tree" "$mdir" \ - -type f -not -path "*/.git*/*" | awk '{print $1}' > \ - "$xbmktmp/project.hash" || err "!h $project $tree" + hash="$(x_ "$sha512sum" "$xbtmp/tmp.hash" | awk '{print $1}' || \ + err)" || err "$hashname: Can't read sha512 of '$xbtmp/tmp.hash'" \ + "project_up_to_date" "$hashdir" "$hashname" "$badhashvar" "$@" - pjhash="$(sha512sum "$xbmktmp/project.hash" | awk '{print $1}')" || : - [ "$pjhash" != "$old_pjhash" ] && badhash="y" - [ -f "$XBMK_CACHE/hash/$project$tree" ] || badhash="y" + if [ "$hash" != "$old_hash" ] || \ + [ ! -f "$XBMK_CACHE/$hashdir/$project$hashname" ]; then + eval "$badhashvar=\"y\"" + fi - printf "%s\n" "$pjhash" > "$XBMK_CACHE/hash/$project$tree" || \ - err "!mk $XBMK_CACHE/hash/$project$tree" + printf "%s\n" "$hash" > "$xbtmp/new.hash" || \ + err "!mkhash $xbtmp/new.hash ($hashdir $hashname $badhashvar)" \ + "project_up_to_date" "$hashdir" "$hashname" "$badhashvar" "$@" - [ "$badhash" != "y" ] || x_ rm -Rf "src/$project/$tree" \ - "elf/$project/$tree" "elf/$project/$target"; : + eval "[ \"\$$badhashvar\" = \"y\" ] && return 1"; : } check_cross_compiler() { cbdir="src/coreboot/$tree" - [ "$project" != "coreboot" ] && cbdir="src/coreboot/default" - [ -n "$xtree" ] && cbdir="src/coreboot/$xtree" + + if [ "$project" != "coreboot" ]; then + cbdir="src/coreboot/default" + fi + if [ -n "$xgcctree" ]; then + cbdir="src/coreboot/$xgcctree" + fi + + xfix="${1%-*}" + + if [ "$xfix" = "x86_64" ]; then + xfix="x64" + fi + + xgccfile="elf/coreboot/$tree/xgcc_${xfix}_was_compiled" + xgccargs="crossgcc-$xfix UPDATED_SUBMODULES=1 CPUS=$XBMK_THREADS" x_ ./mk -f coreboot "${cbdir#src/coreboot/}" + x_ xbmkdir "elf/coreboot/$tree" # TODO: is this needed? export PATH="$xbmkpwd/$cbdir/util/crossgcc/xgcc/bin:$PATH" export CROSS_COMPILE="${xarch% *}-" - [ -n "$xlang" ] && export BUILD_LANGUAGES="$xlang" - # match gnat-X to gcc - check_gnu_path gcc gnat || x_ check_gnu_path gnat gcc + if [ -n "$xlang" ]; then + export BUILD_LANGUAGES="$xlang" + fi - xfix="${1%-*}" && [ "$xfix" = "x86_64" ] && xfix="x64" - xgccargs="crossgcc-$xfix UPDATED_SUBMODULES=1 CPUS=$XBMK_THREADS" + if [ -f "$xgccfile" ]; then + # skip the build, because a build already exists: + + return 0 + fi + + check_gnu_path gcc gnat || x_ check_gnu_path gnat gcc make -C "$cbdir" $xgccargs || x_ make -C "$cbdir" $xgccargs - # we only want to mess with hostcc to build xgcc - remkdir "$XBMK_CACHE/gnupath" + # this tells subsequent runs that the build was already done: + x_ touch "$xgccfile" + + # reset hostcc in PATH: + remkdir "$xbtmp/gnupath" } # fix mismatching gcc/gnat versions on debian trixie/sid. as of december 2024, # trixie/sid had gnat-13 as gnat and gcc-14 as gcc, but has gnat-14 in apt. in # some cases, gcc 13+14 and gnat-13 are present; or gnat-14 and gcc-14, but # gnat in PATH never resolves to gnat-14, because gnat-14 was "experimental" + check_gnu_path() { - command -v "$1" 1>/dev/null || err "Host '$1' unavailable" + if ! command -v "$1" 1>/dev/null; then + err "Host '$1' unavailable" "check_gnu_path" "$@" + fi + + gccdir="" + gccfull="" + gccver="" + gnatdir="" + gnatfull="" + gnatver="" + + if host_gcc_gnat_match "$@"; then + return 0 + fi + + if ! match_gcc_gnat_versions "$@"; then + return 1 + fi +} - eval "`setvars "" gccver gccfull gnatver gnatfull gccdir gnatdir`" - x_ gnu_setver "$1" "$1" || err "Command '$1' unavailable." +# check if gcc/gnat versions already match: + +host_gcc_gnat_match() +{ + if ! gnu_setver "$1" "$1"; then + err "Command '$1' unavailable." "check_gnu_path" "$@" + fi gnu_setver "$2" "$2" || : eval "[ -z \"\$$1ver\" ] && err \"Cannot detect host '$1' version\"" - [ "$gnatfull" = "$gccfull" ] && return 0 + if [ "$gnatfull" != "$gccfull" ]; then + # non-matching gcc/gnat versions + + return 1 + fi +} + +# find all gcc/gnat versions, matching them up in PATH: + +match_gcc_gnat_versions() +{ eval "$1dir=\"$(dirname "$(command -v "$1")")\"" - eval "_gnudir=\"\$$1dir\"; _gnuver=\"\$$1ver\"" - for _bin in "$_gnudir/$2-"*; do - [ "${_bin#"$_gnudir/$2-"}" = "$_gnuver" ] && [ -x "$_bin" ] \ - && _gnuver="${_bin#"$_gnudir/$2-"}" && break; : + eval "_gnudir=\"\$$1dir\"" + eval "_gnuver=\"\$$1ver\"" + + for _bin in "$_gnudir/$2-"* + do + if [ "${_bin#"$_gnudir/$2-"}" = "$_gnuver" ] && [ -x "$_bin" ] + then + _gnuver="${_bin#"$_gnudir/$2-"}" + break + fi done - gnu_setver "$2" "$_gnudir/$2-$_gnuver" || return 1 - [ "$gnatfull" = "$gccfull" ] || return 1 - ( - remkdir "$XBMK_CACHE/gnupath" && x_ cd "$XBMK_CACHE/gnupath" - for _gnubin in "$_gnudir/$2"*"-$_gnuver"; do - _gnuutil="${_gnubin##*/}" && [ -e "$_gnubin" ] && \ - x_ ln -s "$_gnubin" "${_gnuutil%"-$_gnuver"}" + if ! gnu_setver "$2" "$_gnudir/$2-$_gnuver"; then + return 1 + elif [ "$gnatfull" != "$gccfull" ]; then + return 1 + fi + + ( link_gcc_gnat_versions "$@" "$_gnudir" "$_gnuver" ) || \ + err "Can't link '$2-$_gnuver' '$_gnudir'" "check_gnu_path" "$@"; : +} + +# create symlinks in PATH, so that the GCC/GNAT versions match: + +link_gcc_gnat_versions() +{ + _gnudir="$3" + _gnuver="$4" + + remkdir "$xbtmp/gnupath" + + x_ cd "$xbtmp/gnupath" + + for _gnubin in "$_gnudir/$2"*"-$_gnuver" + do + _gnuutil="${_gnubin##*/}" + if [ -e "$_gnubin" ]; then + x_ ln -s "$_gnubin" "${_gnuutil%"-$_gnuver"}" + fi done - ) || err "Cannot create $2-$_gnuver link in $_gnudir"; : } +# get the gcc/gnat version +# fail: return 1 if util not found gnu_setver() { eval "$2 --version 1>/dev/null 2>/dev/null || return 1" + eval "$1ver=\"`"$2" --version 2>/dev/null | head -n1`\"" eval "$1ver=\"\${$1ver##* }\"" eval "$1full=\"\$$1ver\"" @@ -265,80 +618,155 @@ gnu_setver() check_defconfig() { - [ -f "$defconfig" ] || $dry err "$project/$target: missing defconfig" - dest_dir="$elfdir/$target/${defconfig#"$target_dir/config/"}" + if [ ! -f "$defconfig" ]; then + $if_not_dry_build \ + err "$project/$target: no config" "check_defconfig" "$@" + fi + + dest_dir="$elfdir/$tree/$target/${defconfig#"$target_dir/config/"}" + + # skip build if a previous one exists: - $dry elfcheck || return 1 # skip build if a previous one exists - $dry x_ mkdir -p "$dest_dir" + $if_dry_build \ + return 0 + if ! elfcheck; then + return 1 + fi } elfcheck() { # TODO: *STILL* very hacky check. do it properly (based on build.list) - ( fx_ "exit 1" find "$dest_dir" -type f ) || return 1; : + + ( fx_ "eval exit 1 && err" find "$dest_dir" -type f ) || return 1; : } handle_makefile() { - $dry check_makefile "$srcdir" && x_ make -C "$srcdir" $cleanargs clean + if $if_not_dry_build check_makefile "$srcdir"; then + $if_not_dry_build \ + x_ make -C "$srcdir" $cleanargs clean + fi + + if [ -f "$defconfig" ]; then + x_ cp "$defconfig" "$srcdir/.config" + fi - [ -f "$defconfig" ] && x_ cp "$defconfig" "$srcdir/.config" - [ -n "$mode" ] || [ -n "$btype" ] || $dry make -C \ - "$srcdir" silentoldconfig || make -C "$srcdir" oldconfig || : + run_make_command || \ + err "no makefile!" "handle_makefile" "$@" - run_make_command || err "handle_makefile $srcdir: no makefile!" + _copy=".config" - _copy=".config" && [ "$mode" = "savedefconfig" ] && _copy="defconfig" - [ "${mode%config}" = "$mode" ] || \ - $dry x_ cp "$srcdir/$_copy" "$defconfig" + if [ "$mode" = "savedefconfig" ]; then + _copy="defconfig" + fi + + if [ "${mode%config}" != "$mode" ]; then + $if_not_dry_build \ + x_ cp "$srcdir/$_copy" "$defconfig"; : + fi - [ -e "$srcdir/.git" ] && [ "$project" = "u-boot" ] && \ - [ "$mode" = "distclean" ] && \ - $dry x_ git -C "$srcdir" $cleanargs clean -fdx; : + if [ -e "$srcdir/.git" ] && [ "$project" = "u-boot" ] && \ + [ "$mode" = "distclean" ]; then + $if_not_dry_build \ + x_ git -C "$srcdir" $cleanargs clean -fdx; : + fi } run_make_command() { - [ -n "$mode" ] || x_ $premake + if [ -z "$mode" ]; then + x_ $premake + fi - $dry check_cmake "$srcdir" && [ -z "$mode" ] && \ - $dry check_autoconf "$srcdir" - $dry check_makefile "$srcdir" || return 1 + if $if_not_dry_build check_cmake "$srcdir"; then + if [ -z "$mode" ]; then + $if_not_dry_build \ + check_autoconf "$srcdir" + fi + fi + if ! $if_not_dry_build check_makefile "$srcdir"; then + return 1 + fi + + $if_not_dry_build \ + x_ make -C "$srcdir" $mode -j$XBMK_THREADS $makeargs + + if [ -z "$mode" ]; then + x_ $mkhelper + fi - $dry x_ make -C "$srcdir" $mode -j$XBMK_THREADS $makeargs - [ -n "$mode" ] || x_ $mkhelper + if ! check_makefile "$srcdir"; then + return 0 + fi - [ "$mode" != "clean" ] || \ - $dry make -C "$srcdir" $cleanargs distclean || :; : + if [ "$mode" = "clean" ]; then + $if_dry_build \ + return 0 + if ! make -C "$srcdir" $cleanargs distclean; then + x_ make -C "$srcdir" $cleanargs clean + fi + fi } check_cmake() { - [ -z "$cmakedir" ] || $dry check_makefile "$1" || cmake -B "$1" \ - "$1/$cmakedir" || $dry x_ check_makefile "$1" - [ -z "$cmakedir" ] || $dry x_ check_makefile "$1"; : + $if_dry_build \ + return 0 + if [ ! -n "$cmakedir" ]; then + return 0 + elif ! check_makefile "$1"; then + if ! cmake -B "$1" "$1/$cmakedir"; then + x_ check_makefile "$1" + fi + fi + x_ check_makefile "$1"; : } check_autoconf() { ( - cd "$1" || err "!cd $1" - [ -f "bootstrap" ] && x_ ./bootstrap $bootstrapargs - [ -f "autogen.sh" ] && x_ ./autogen.sh $autogenargs - [ -f "configure" ] && x_ ./configure $autoconfargs; : - ) || err "can't bootstrap project: $1"; : + x_ cd "$1" + + if [ -f "bootstrap" ]; then + x_ ./bootstrap $bootstrapargs + fi + if [ -f "autogen.sh" ]; then + x_ ./autogen.sh $autogenargs + fi + if [ -f "configure" ]; then + x_ ./configure $autoconfargs; : + fi + + ) || err "can't bootstrap project: $1" "check_autoconf" "$@"; : } check_makefile() { - [ -f "$1/Makefile" ] || [ -f "$1/makefile" ] || \ - [ -f "$1/GNUmakefile" ] || return 1; : + if [ ! -f "$1/Makefile" ] && [ ! -f "$1/makefile" ] && \ + [ ! -f "$1/GNUmakefile" ]; then + + return 1 + fi } copy_elf() { - [ -f "$listfile" ] && x_ mkdir -p "$dest_dir" && while read -r f; do - [ -f "$srcdir/$f" ] && x_ cp "$srcdir/$f" "$dest_dir" - done < "$listfile" - x_ make clean -C "$srcdir" $cleanargs + if [ -f "$listfile" ]; then + x_ xbmkdir "$dest_dir" + fi + + if [ -f "$listfile" ]; then + while read -r f + do + if [ -f "$srcdir/$f" ]; then + x_ cp "$srcdir/$f" "$dest_dir" + fi + + done < "$listfile" || err \ + "cannot read '$listfile'" "copy_elf" "$@"; : + fi + + ( x_ make clean -C "$srcdir" $cleanargs ) || \ + err "can't make-clean '$srcdir'" "copy_elf" "$@"; : } |