forks/apenwarr-redo
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
apenwarr-redo/redo/sh.do

69 lines
1.7 KiB
Text
Raw Permalink Normal View History

Automatically select a good shell instead of relying on /bin/sh. This includes a fairly detailed test of various known shell bugs from the autoconf docs. The idea here is that if redo works on your system, you should be able to rely on a *good* shell to run your .do files; you shouldn't have to work around zillions of bugs like autoconf does.
2010-12-21 04:19:50 -08:00
exec >&2
Directory reorg: move code into redo/, generate binaries in bin/. It's time to start preparing for a version of redo that doesn't work unless we build it first (because it will rely on C modules, and eventually be rewritten in C altogether). To get rolling, remove the old-style symlinks to the main programs, and rename those programs from redo-*.py to redo/cmd_*.py. We'll also move all library functions into the redo/ dir, which is a more python-style naming convention. Previously, install.do was generating wrappers for installing in /usr/bin, which extend sys.path and then import+run the right file. This made "installed" redo work quite differently from running redo inside its source tree. Instead, let's always generate the wrappers in bin/, and not make anything executable except those wrappers. Since we're generating wrappers anyway, let's actually auto-detect the right version of python for the running system; distros can't seem to agree on what to call their python2 binaries (sigh). We'll fill in the right #! shebang lines. Since we're doing that, we can stop using /usr/bin/env, which will a) make things slightly faster, and b) let us use "python -S", which tells python not to load a bunch of extra crap we're not using, thus improving startup times. Annoyingly, we now have to build redo using minimal/do, then run the tests using bin/redo. To make this less annoying, we add a toplevel ./do script that knows the right steps, and a Makefile (whee!) for people who are used to typing 'make' and 'make test' and 'make clean'.
2018-12-03 21:39:15 -05:00
redo-ifchange ../t/shelltest.od
Automatically select a good shell instead of relying on /bin/sh. This includes a fairly detailed test of various known shell bugs from the autoconf docs. The idea here is that if redo works on your system, you should be able to rely on a *good* shell to run your .do files; you shouldn't have to work around zillions of bugs like autoconf does.
2010-12-21 04:19:50 -08:00
Directory reorg: move code into redo/, generate binaries in bin/. It's time to start preparing for a version of redo that doesn't work unless we build it first (because it will rely on C modules, and eventually be rewritten in C altogether). To get rolling, remove the old-style symlinks to the main programs, and rename those programs from redo-*.py to redo/cmd_*.py. We'll also move all library functions into the redo/ dir, which is a more python-style naming convention. Previously, install.do was generating wrappers for installing in /usr/bin, which extend sys.path and then import+run the right file. This made "installed" redo work quite differently from running redo inside its source tree. Instead, let's always generate the wrappers in bin/, and not make anything executable except those wrappers. Since we're generating wrappers anyway, let's actually auto-detect the right version of python for the running system; distros can't seem to agree on what to call their python2 binaries (sigh). We'll fill in the right #! shebang lines. Since we're doing that, we can stop using /usr/bin/env, which will a) make things slightly faster, and b) let us use "python -S", which tells python not to load a bunch of extra crap we're not using, thus improving startup times. Annoyingly, we now have to build redo using minimal/do, then run the tests using bin/redo. To make this less annoying, we add a toplevel ./do script that knows the right steps, and a Makefile (whee!) for people who are used to typing 'make' and 'make test' and 'make clean'.
2018-12-03 21:39:15 -05:00
rm -rf $1.new
Automatically select a good shell instead of relying on /bin/sh. This includes a fairly detailed test of various known shell bugs from the autoconf docs. The idea here is that if redo works on your system, you should be able to rely on a *good* shell to run your .do files; you shouldn't have to work around zillions of bugs like autoconf does.
2010-12-21 04:19:50 -08:00
mkdir $1.new
GOOD=
WARN=
redo-sh: reverse a case that caused 'set -e' to abort on zsh. Correctly, I might add. It's too bad none of my other shells did it. Sigh.
2011-05-08 01:25:26 -04:00
# Note: list low-functionality, maximally POSIX-like shells before more
# powerful ones. We want weaker shells to take precedence, as long as they
# pass the tests, because weaker shells are more likely to point out when you
# use some non-portable feature.
redo/sh.do: include the 'lksh' variant of mksh. This one attempts to be a much closer match to POSIX, and seems to succeed, giving only warning W118.
2018-12-17 13:21:42 +00:00
for sh in dash /usr/xpg4/bin/sh ash posh \
lksh mksh ksh ksh88 ksh93 pdksh \
sh.do: explicitly check /bin/sh instead of sh. Because our experiment involves creating a file called redo/sh, and the redo directory (or some other version of redo's dirctory) might be on the path, just testing 'sh' is actually wrong: we might end up with some earlier version of redo-sh. Instead, specifically for sh, always demand that we test /bin/sh.
2018-12-04 02:31:41 -05:00
zsh bash busybox /bin/sh; do
shelltest.od: we accidentally treated some fails as mere warnings. We were setting a global variable FAIL on failure, but if we failed inside a subshell (which a very small number of tests might do), this setting would be lost. The script output (a series of failed/warning lines) was still valid, but not the return code, so the shell might be selected even if one of these tests failed. To avoid the problem, put the fail/warning state in the filesystem instead, which is shared across subshells.
2018-12-17 12:33:17 +00:00
printf " %-22s" "$sh..."
redo-sh.do: hide warning output from 'which' in some shells.
2011-01-02 11:49:51 -08:00
FOUND=`which $sh 2>/dev/null` || { echo "missing"; continue; }
Automatically select a good shell instead of relying on /bin/sh. This includes a fairly detailed test of various known shell bugs from the autoconf docs. The idea here is that if redo works on your system, you should be able to rely on a *good* shell to run your .do files; you shouldn't have to work around zillions of bugs like autoconf does.
2010-12-21 04:19:50 -08:00
redo-sh.do: wrap long lines.
2011-01-02 11:49:34 -08:00
# It's important for the file to actually be named 'sh'. Some
# shells (like bash and zsh) only go into POSIX-compatible mode if
# they have that name. If they're not in POSIX-compatible mode,
# they'll fail the test.
Automatically select a good shell instead of relying on /bin/sh. This includes a fairly detailed test of various known shell bugs from the autoconf docs. The idea here is that if redo works on your system, you should be able to rely on a *good* shell to run your .do files; you shouldn't have to work around zillions of bugs like autoconf does.
2010-12-21 04:19:50 -08:00
rm -f $1.new/sh
ln -s $FOUND $1.new/sh
Directory reorg: move code into redo/, generate binaries in bin/. It's time to start preparing for a version of redo that doesn't work unless we build it first (because it will rely on C modules, and eventually be rewritten in C altogether). To get rolling, remove the old-style symlinks to the main programs, and rename those programs from redo-*.py to redo/cmd_*.py. We'll also move all library functions into the redo/ dir, which is a more python-style naming convention. Previously, install.do was generating wrappers for installing in /usr/bin, which extend sys.path and then import+run the right file. This made "installed" redo work quite differently from running redo inside its source tree. Instead, let's always generate the wrappers in bin/, and not make anything executable except those wrappers. Since we're generating wrappers anyway, let's actually auto-detect the right version of python for the running system; distros can't seem to agree on what to call their python2 binaries (sigh). We'll fill in the right #! shebang lines. Since we're doing that, we can stop using /usr/bin/env, which will a) make things slightly faster, and b) let us use "python -S", which tells python not to load a bunch of extra crap we're not using, thus improving startup times. Annoyingly, we now have to build redo using minimal/do, then run the tests using bin/redo. To make this less annoying, we add a toplevel ./do script that knows the right steps, and a Makefile (whee!) for people who are used to typing 'make' and 'make test' and 'make clean'.
2018-12-03 21:39:15 -05:00
SH=$PWD/$1.new/sh
Automatically select a good shell instead of relying on /bin/sh. This includes a fairly detailed test of various known shell bugs from the autoconf docs. The idea here is that if redo works on your system, you should be able to rely on a *good* shell to run your .do files; you shouldn't have to work around zillions of bugs like autoconf does.
2010-12-21 04:19:50 -08:00
set +e
Fix minimal/do and tests when built in a path containing spaces. Basically all just missing quotes around shell strings that use $PWD. Most paths inside a project, since redo uses relative paths, only need to worry when project-internal directories or filenames have spaces in them. Reported-by: Jeff Stearns <jeff.stearns@gmail.com>
2018-12-11 01:19:58 +00:00
( cd ../t && "$SH" shelltest.od ) >shelltest.tmp 2>&1
Automatically select a good shell instead of relying on /bin/sh. This includes a fairly detailed test of various known shell bugs from the autoconf docs. The idea here is that if redo works on your system, you should be able to rely on a *good* shell to run your .do files; you shouldn't have to work around zillions of bugs like autoconf does.
2010-12-21 04:19:50 -08:00
RV=$?
set -e
redo-sh.do: prettier log messages. Make it easier to see which shells fail/warn about what.
2011-03-23 11:24:17 -07:00
msgs=
crash=
while read line; do
#echo "line: '$line'" >&2
stripw=${line#warning: }
stripf=${line#failed: }
shelltest.od: add more "set -e" tests and add a 'skip' return code. Based on the earlier t/000-set-minus-e bug in minimal/do on some shells, let's add some extra tests that reveal the weirdness on those shells. Unfortunately because they are so popular (including bash and zsh), we can't reject them outright for failing this one. While we're here, add a new return code, "skip", which notes that a test has failed but is not important enough to be considered a warning or failure. Previously we just had these commented out, which is not quite obvious enough. ...and I updated a few comments while reviewing some of the older tests.
2018-12-17 12:35:32 +00:00
strips=${line#skip: }
redo-sh.do: prettier log messages. Make it easier to see which shells fail/warn about what.
2011-03-23 11:24:17 -07:00
crash=$line
redo-sh: reverse a case that caused 'set -e' to abort on zsh. Correctly, I might add. It's too bad none of my other shells did it. Sigh.
2011-05-08 01:25:26 -04:00
[ "$line" = "$stripw" ] || msgs="$msgs W$stripw"
[ "$line" = "$stripf" ] || msgs="$msgs F$stripf"
shelltest.od: add more "set -e" tests and add a 'skip' return code. Based on the earlier t/000-set-minus-e bug in minimal/do on some shells, let's add some extra tests that reveal the weirdness on those shells. Unfortunately because they are so popular (including bash and zsh), we can't reject them outright for failing this one. While we're here, add a new return code, "skip", which notes that a test has failed but is not important enough to be considered a warning or failure. Previously we just had these commented out, which is not quite obvious enough. ...and I updated a few comments while reviewing some of the older tests.
2018-12-17 12:35:32 +00:00
[ "$line" = "$strips" ] || msgs="$msgs s$strips"
Directory reorg: move code into redo/, generate binaries in bin/. It's time to start preparing for a version of redo that doesn't work unless we build it first (because it will rely on C modules, and eventually be rewritten in C altogether). To get rolling, remove the old-style symlinks to the main programs, and rename those programs from redo-*.py to redo/cmd_*.py. We'll also move all library functions into the redo/ dir, which is a more python-style naming convention. Previously, install.do was generating wrappers for installing in /usr/bin, which extend sys.path and then import+run the right file. This made "installed" redo work quite differently from running redo inside its source tree. Instead, let's always generate the wrappers in bin/, and not make anything executable except those wrappers. Since we're generating wrappers anyway, let's actually auto-detect the right version of python for the running system; distros can't seem to agree on what to call their python2 binaries (sigh). We'll fill in the right #! shebang lines. Since we're doing that, we can stop using /usr/bin/env, which will a) make things slightly faster, and b) let us use "python -S", which tells python not to load a bunch of extra crap we're not using, thus improving startup times. Annoyingly, we now have to build redo using minimal/do, then run the tests using bin/redo. To make this less annoying, we add a toplevel ./do script that knows the right steps, and a Makefile (whee!) for people who are used to typing 'make' and 'make test' and 'make clean'.
2018-12-03 21:39:15 -05:00
done <shelltest.tmp
rm -f shelltest.tmp
redo-sh.do: prettier log messages. Make it easier to see which shells fail/warn about what.
2011-03-23 11:24:17 -07:00
msgs=${msgs# }
crash=${crash##*:}
crash=${crash# }
Automatically select a good shell instead of relying on /bin/sh. This includes a fairly detailed test of various known shell bugs from the autoconf docs. The idea here is that if redo works on your system, you should be able to rely on a *good* shell to run your .do files; you shouldn't have to work around zillions of bugs like autoconf does.
2010-12-21 04:19:50 -08:00
case $RV in
redo-sh: reverse a case that caused 'set -e' to abort on zsh. Correctly, I might add. It's too bad none of my other shells did it. Sigh.
2011-05-08 01:25:26 -04:00
40) echo "ok $msgs"; [ -n "$GOOD" ] || GOOD=$FOUND ;;
redo-sh.do: prettier log messages. Make it easier to see which shells fail/warn about what.
2011-03-23 11:24:17 -07:00
41) echo "failed $msgs" ;;
42) echo "warnings $msgs"; [ -n "$WARN" ] || WARN=$FOUND ;;
shelltest: use a more magical magic number for success. There may be some odd situation where a shell returns 0 despite not executing the script correctly; now 0 is an error condition.
2011-04-17 23:39:53 -04:00
*) echo "crash $crash" ;;
Automatically select a good shell instead of relying on /bin/sh. This includes a fairly detailed test of various known shell bugs from the autoconf docs. The idea here is that if redo works on your system, you should be able to rely on a *good* shell to run your .do files; you shouldn't have to work around zillions of bugs like autoconf does.
2010-12-21 04:19:50 -08:00
esac
done
Directory reorg: move code into redo/, generate binaries in bin/. It's time to start preparing for a version of redo that doesn't work unless we build it first (because it will rely on C modules, and eventually be rewritten in C altogether). To get rolling, remove the old-style symlinks to the main programs, and rename those programs from redo-*.py to redo/cmd_*.py. We'll also move all library functions into the redo/ dir, which is a more python-style naming convention. Previously, install.do was generating wrappers for installing in /usr/bin, which extend sys.path and then import+run the right file. This made "installed" redo work quite differently from running redo inside its source tree. Instead, let's always generate the wrappers in bin/, and not make anything executable except those wrappers. Since we're generating wrappers anyway, let's actually auto-detect the right version of python for the running system; distros can't seem to agree on what to call their python2 binaries (sigh). We'll fill in the right #! shebang lines. Since we're doing that, we can stop using /usr/bin/env, which will a) make things slightly faster, and b) let us use "python -S", which tells python not to load a bunch of extra crap we're not using, thus improving startup times. Annoyingly, we now have to build redo using minimal/do, then run the tests using bin/redo. To make this less annoying, we add a toplevel ./do script that knows the right steps, and a Makefile (whee!) for people who are used to typing 'make' and 'make test' and 'make clean'.
2018-12-03 21:39:15 -05:00
rm -rf $1.new $3
Automatically select a good shell instead of relying on /bin/sh. This includes a fairly detailed test of various known shell bugs from the autoconf docs. The idea here is that if redo works on your system, you should be able to rely on a *good* shell to run your .do files; you shouldn't have to work around zillions of bugs like autoconf does.
2010-12-21 04:19:50 -08:00
if [ -n "$GOOD" ]; then
echo "Selected perfect shell: $GOOD"
Directory reorg: move code into redo/, generate binaries in bin/. It's time to start preparing for a version of redo that doesn't work unless we build it first (because it will rely on C modules, and eventually be rewritten in C altogether). To get rolling, remove the old-style symlinks to the main programs, and rename those programs from redo-*.py to redo/cmd_*.py. We'll also move all library functions into the redo/ dir, which is a more python-style naming convention. Previously, install.do was generating wrappers for installing in /usr/bin, which extend sys.path and then import+run the right file. This made "installed" redo work quite differently from running redo inside its source tree. Instead, let's always generate the wrappers in bin/, and not make anything executable except those wrappers. Since we're generating wrappers anyway, let's actually auto-detect the right version of python for the running system; distros can't seem to agree on what to call their python2 binaries (sigh). We'll fill in the right #! shebang lines. Since we're doing that, we can stop using /usr/bin/env, which will a) make things slightly faster, and b) let us use "python -S", which tells python not to load a bunch of extra crap we're not using, thus improving startup times. Annoyingly, we now have to build redo using minimal/do, then run the tests using bin/redo. To make this less annoying, we add a toplevel ./do script that knows the right steps, and a Makefile (whee!) for people who are used to typing 'make' and 'make test' and 'make clean'.
2018-12-03 21:39:15 -05:00
ln -s $GOOD $3
Automatically select a good shell instead of relying on /bin/sh. This includes a fairly detailed test of various known shell bugs from the autoconf docs. The idea here is that if redo works on your system, you should be able to rely on a *good* shell to run your .do files; you shouldn't have to work around zillions of bugs like autoconf does.
2010-12-21 04:19:50 -08:00
elif [ -n "$WARN" ]; then
echo "Selected mostly good shell: $WARN"
Directory reorg: move code into redo/, generate binaries in bin/. It's time to start preparing for a version of redo that doesn't work unless we build it first (because it will rely on C modules, and eventually be rewritten in C altogether). To get rolling, remove the old-style symlinks to the main programs, and rename those programs from redo-*.py to redo/cmd_*.py. We'll also move all library functions into the redo/ dir, which is a more python-style naming convention. Previously, install.do was generating wrappers for installing in /usr/bin, which extend sys.path and then import+run the right file. This made "installed" redo work quite differently from running redo inside its source tree. Instead, let's always generate the wrappers in bin/, and not make anything executable except those wrappers. Since we're generating wrappers anyway, let's actually auto-detect the right version of python for the running system; distros can't seem to agree on what to call their python2 binaries (sigh). We'll fill in the right #! shebang lines. Since we're doing that, we can stop using /usr/bin/env, which will a) make things slightly faster, and b) let us use "python -S", which tells python not to load a bunch of extra crap we're not using, thus improving startup times. Annoyingly, we now have to build redo using minimal/do, then run the tests using bin/redo. To make this less annoying, we add a toplevel ./do script that knows the right steps, and a Makefile (whee!) for people who are used to typing 'make' and 'make test' and 'make clean'.
2018-12-03 21:39:15 -05:00
ln -s $WARN $3
Automatically select a good shell instead of relying on /bin/sh. This includes a fairly detailed test of various known shell bugs from the autoconf docs. The idea here is that if redo works on your system, you should be able to rely on a *good* shell to run your .do files; you shouldn't have to work around zillions of bugs like autoconf does.
2010-12-21 04:19:50 -08:00
else
echo "No good shells found! Maybe install dash, bash, or zsh."
redo-sh: reverse a case that caused 'set -e' to abort on zsh. Correctly, I might add. It's too bad none of my other shells did it. Sigh.
2011-05-08 01:25:26 -04:00
exit 13
Automatically select a good shell instead of relying on /bin/sh. This includes a fairly detailed test of various known shell bugs from the autoconf docs. The idea here is that if redo works on your system, you should be able to rely on a *good* shell to run your .do files; you shouldn't have to work around zillions of bugs like autoconf does.
2010-12-21 04:19:50 -08:00
fi
Reference in a new issue Copy permalink