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

66 lines
1.7 KiB
Text
Raw 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: downgrade failures that affected dash; add a bash warning. I feel a little dirty doing this, but the way the code was before, redo almost always picked bash as the shell. bash is way too overpowered and this led to bashisms in do scripts unnecessarily. The two failures in dash are things that I would really like to have, but they haven't materialized after 6 years, so I guess we should be realistic. To appropriately penalize bash for asking for trouble, I added a warning about [ 1 == 1 ] syntax being valid (as opposed to the POSIX correct [ 1 = 1 ]). This allows dash to be selected ahead of bash. I also moved 'sh' to the end of the list, because although it's the weakest shell on some systems, on other systems it's just bash. And I put zsh in front of bash, because fewer people have zsh and we want them to test zsh.
2018-10-12 03:49:22 -04:00
for sh in dash /usr/xpg4/bin/sh ash posh 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: }
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"
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