2023-09-25 12:37:35 +02:00
|
|
|
# SPDX-License-Identifier: GPL-3.0-or-later
|
2024-01-01 18:08:38 +01:00
|
|
|
# SPDX-FileCopyrightText: 2020,2021,2023,2024 Leah Rowe <leah@libreboot.org>
|
2023-10-07 07:55:10 +02:00
|
|
|
# SPDX-FileCopyrightText: 2022 Caleb La Grange <thonkpeasant@protonmail.com>
|
|
|
|
|
|
2024-01-21 13:59:02 +01:00
|
|
|
eval "$(setvars "" _target rev _xm loc url bkup_url depend tree_depend xtree)"
|
2023-10-07 07:55:10 +02:00
|
|
|
|
|
|
|
|
fetch_project_trees()
|
|
|
|
|
{
|
|
|
|
|
_target="${target}"
|
|
|
|
|
[ -d "src/${project}/${project}" ] || fetch_from_upstream
|
|
|
|
|
fetch_config
|
2023-10-20 09:03:45 +02:00
|
|
|
if [ -d "src/${project}/${tree}" ]; then
|
2023-10-07 07:55:10 +02:00
|
|
|
printf "download/%s %s (%s): exists\n" \
|
2023-10-20 09:03:45 +02:00
|
|
|
"${project}" "${tree}" "${_target}" 1>&2
|
|
|
|
|
return 0
|
|
|
|
|
fi
|
2023-10-07 07:55:10 +02:00
|
|
|
prepare_new_tree
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fetch_from_upstream()
|
|
|
|
|
{
|
|
|
|
|
[ -d "src/${project}/${project}" ] && return 0
|
|
|
|
|
|
|
|
|
|
x_ mkdir -p "src/${project}"
|
2023-10-20 05:10:50 +02:00
|
|
|
fetch_project_repo "${project}"
|
2023-10-07 07:55:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fetch_config()
|
|
|
|
|
{
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 02:19:39 +01:00
|
|
|
rm -f "${cfgsdir}/"*/seen || $err "fetch_config ${cfgsdir}: !rm seen"
|
2024-01-26 12:15:23 +01:00
|
|
|
eval "$(setvars "" xtree tree_depend)"
|
2023-10-07 07:55:10 +02:00
|
|
|
while true; do
|
|
|
|
|
eval "$(setvars "" rev tree)"
|
|
|
|
|
_xm="fetch_config ${project}/${_target}"
|
|
|
|
|
load_target_config "${_target}"
|
2023-12-19 03:23:46 +01:00
|
|
|
[ "${_target}" = "${tree}" ] && break
|
|
|
|
|
_target="${tree}"
|
2023-10-07 07:55:10 +02:00
|
|
|
done
|
2024-01-21 13:59:02 +01:00
|
|
|
[ -n "$tree_depend" ] && [ "$tree_depend" != "$tree" ] && \
|
2024-01-21 16:50:21 +01:00
|
|
|
x_ ./update trees -f "$project" "$tree_depend"; return 0
|
2023-10-07 07:55:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
load_target_config()
|
|
|
|
|
{
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 02:19:39 +01:00
|
|
|
[ -f "$cfgsdir/$1/target.cfg" ] || $err "$1: target.cfg missing"
|
2023-10-07 07:55:10 +02:00
|
|
|
[ -f "${cfgsdir}/${1}/seen" ] && \
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 02:19:39 +01:00
|
|
|
$err "${_xm} check: infinite loop in tree definitions"
|
2023-10-07 07:55:10 +02:00
|
|
|
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 02:19:39 +01:00
|
|
|
. "$cfgsdir/$1/target.cfg" || $err "load_target_config !$cfgsdir/$1"
|
|
|
|
|
touch "$cfgsdir/$1/seen" || $err "load_config $cfgsdir/$1: !mk seen"
|
2023-10-07 07:55:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
prepare_new_tree()
|
|
|
|
|
{
|
2023-12-24 10:04:36 +01:00
|
|
|
printf "Creating %s tree %s (%s)\n" "$project" "$tree" "$_target"
|
2023-10-07 07:55:10 +02:00
|
|
|
|
2024-01-01 16:02:34 +01:00
|
|
|
cp -R "src/${project}/${project}" "${tmpgit}" || \
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 02:19:39 +01:00
|
|
|
$err "prepare_new_tree ${project}/${tree}: can't make tmpclone"
|
2024-01-01 16:02:34 +01:00
|
|
|
git_prep "$PWD/$cfgsdir/$tree/patches" "src/$project/$tree" "update"
|
2023-10-07 07:55:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fetch_project_repo()
|
|
|
|
|
{
|
2024-01-26 12:15:23 +01:00
|
|
|
eval "$(setvars "" xtree tree_depend)"
|
|
|
|
|
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 02:19:39 +01:00
|
|
|
scan_config "${project}" "config/git"
|
|
|
|
|
[ -z "${loc+x}" ] && $err "fetch_project_repo $project: loc not set"
|
|
|
|
|
[ -z "${url+x}" ] && $err "fetch_project_repo $project: url not set"
|
2023-10-07 07:55:10 +02:00
|
|
|
|
|
|
|
|
clone_project
|
2023-10-20 04:29:55 +02:00
|
|
|
[ -z "${depend}" ] || for d in ${depend} ; do
|
2023-10-20 01:17:30 +02:00
|
|
|
x_ ./update trees -f ${d}
|
2023-10-07 07:55:10 +02:00
|
|
|
done
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 02:19:39 +01:00
|
|
|
rm -Rf "${tmpgit}" || $err "fetch_repo: !rm -Rf ${tmpgit}"
|
2023-10-07 07:55:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
clone_project()
|
|
|
|
|
{
|
|
|
|
|
loc="${loc#src/}"
|
|
|
|
|
loc="src/${loc}"
|
2023-10-20 10:12:23 +02:00
|
|
|
if [ -d "${loc}" ]; then
|
2023-10-20 10:13:49 +02:00
|
|
|
printf "%s already exists, so skipping download\n" "$loc" 1>&2
|
2023-10-20 10:12:23 +02:00
|
|
|
return 0
|
|
|
|
|
fi
|
2023-10-07 07:55:10 +02:00
|
|
|
|
2024-01-01 16:02:34 +01:00
|
|
|
git clone $url "$tmpgit" || git clone $bkup_url "$tmpgit" \
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 02:19:39 +01:00
|
|
|
|| $err "clone_project: could not download ${project}"
|
2024-01-01 16:02:34 +01:00
|
|
|
git_prep "$PWD/config/$project/patches" "$loc"
|
2023-10-07 07:55:10 +02:00
|
|
|
}
|
2023-09-25 12:37:35 +02:00
|
|
|
|
2024-01-01 16:02:34 +01:00
|
|
|
git_prep()
|
2023-09-25 13:17:02 +02:00
|
|
|
{
|
2024-01-01 16:02:34 +01:00
|
|
|
_patchdir="$1"
|
|
|
|
|
_loc="$2"
|
|
|
|
|
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 02:19:39 +01:00
|
|
|
[ -z "${rev+x}" ] && $err "git_prep $_loc: rev not set"
|
|
|
|
|
git -C "$tmpgit" reset --hard $rev || $err "git -C $_loc: !reset $rev"
|
|
|
|
|
git_am_patches "$tmpgit" "$_patchdir" || $err "!am $_loc $_patchdir"
|
2024-01-01 16:02:34 +01:00
|
|
|
|
2024-01-01 17:42:35 +01:00
|
|
|
if [ "$project" != "coreboot" ] || [ $# -gt 2 ]; then
|
|
|
|
|
[ ! -f "$tmpgit/.gitmodules" ] || git -C "$tmpgit" submodule \
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 02:19:39 +01:00
|
|
|
update --init --checkout || $err "git_prep $_loc: !submod"
|
2024-01-21 07:26:23 +01:00
|
|
|
if [ "$project" = "coreboot" ] && [ -n "$xtree" ] && \
|
|
|
|
|
[ "$xtree" != "$tree" ]; then
|
|
|
|
|
(
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 02:19:39 +01:00
|
|
|
cd "$tmpgit/util" || $err "prep $_loc: !cd $tmpgit/util"
|
|
|
|
|
rm -Rf crossgcc || $err "prep $_loc: !rm xgcc"
|
2024-01-21 07:26:23 +01:00
|
|
|
ln -s "../../$xtree/util/crossgcc" crossgcc || \
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 02:19:39 +01:00
|
|
|
$err "prep $_loc: can't create xgcc symlink"
|
|
|
|
|
) || $err "prep $_loc: can't create xgcc symlink"
|
2024-01-21 07:26:23 +01:00
|
|
|
fi
|
2024-01-01 17:42:35 +01:00
|
|
|
fi
|
2024-01-01 16:02:34 +01:00
|
|
|
|
|
|
|
|
[ "$_loc" = "${_loc%/*}" ] || x_ mkdir -p "${_loc%/*}"
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 02:19:39 +01:00
|
|
|
mv "$tmpgit" "$_loc" || $err "git_prep: !mv $tmpgit $_loc"
|
2024-01-21 07:26:23 +01:00
|
|
|
[ -n "$xtree" ] && [ ! -d "src/coreboot/$xtree" ] && \
|
|
|
|
|
x_ ./update project trees -f coreboot "$xtree"; return 0
|
2024-01-01 11:30:19 +01:00
|
|
|
}
|
|
|
|
|
|
2023-09-25 12:37:35 +02:00
|
|
|
git_am_patches()
|
|
|
|
|
{
|
2024-01-01 15:14:25 +01:00
|
|
|
for _patch in "$2/"*; do
|
|
|
|
|
[ -L "$_patch" ] || [ ! -f "$_patch" ] || git -C "$1" am \
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 02:19:39 +01:00
|
|
|
"$_patch" || $err "git_am $1 $2: !git am $_patch"; continue
|
2023-09-25 12:37:35 +02:00
|
|
|
done
|
2024-01-01 15:14:25 +01:00
|
|
|
for _patches in "$2/"*; do
|
|
|
|
|
[ ! -L "$_patches" ] && [ -d "$_patches" ] && \
|
|
|
|
|
git_am_patches "$1" "$_patches"; continue
|
2023-09-25 13:00:43 +02:00
|
|
|
done
|
2023-09-25 12:37:35 +02:00
|
|
|
}
|