mjhjmtu

Consider this snippet:

stop () 
 echo "$1" 1>&2
 exit 1


func () 
 if false; then
 echo "foo"
 else
 stop "something went wrong"
 fi

Normally when func is called it will cause the script to terminate, which is the intended behaviour. However, if it's executed in a sub-shell, such as in

result=`func`

it will not exit the script. This means the calling code has to check the exit status of the function every time. Is there a way to avoid this? Is this what set -e is for?

You could kill the original shell (kill $$) before calling exit, and that'd probably work. But:

• it seems rather ugly to me


• it will break if you have a second subshell in there, i.e., use a subshell inside a subshell.

Instead, you could use one of the several ways to pass back a value in the Bash FAQ. Most of them aren't so great, unfortunately. You may just be stuck checking for errors after each function call (-e has a lot of problems). Either that, or switch to Perl.

You could decide that the exit status 77 for instance means exit any level of subshell, and do

set -E
trap '[ "$?" -ne 77 ] || exit 77' ERR

(
 echo here
 (
 echo there
 (
 exit 12 # not 77, exit only this subshell
 )
 echo ici
 exit 77 # exit all subshells
 )
 echo not here
)
echo not here either

set -E in combination with ERR traps is a bit like an improved version of set -e in that it allows you to define your own error handling.

In zsh, ERR traps are inherited automatically, so you don't need set -E, you can also define traps as TRAPERR() functions, and modify them through $functions[TRAPERR], like functions[TRAPERR]="echo was here; $functions[TRAPERR]"

As an alternative to kill $$, you may also try kill 0, it will work in the case of nested subshells (all callers and side process will receive the signal) … but it's still brutal and ugly.

Try this ...

stop () 
 echo "$1" 1>&2
 exit 1


func () 
 if $1; then
 echo "foo"
 else
 stop "something went wrong"
 fi


echo "shell..."
func $1

echo "subshell..."
result=`func $1`

echo "shell..."
echo "result=$result"

The results I get are ...

# test_exitsubshell true
shell...
foo
subshell...
shell...
result=foo
# test_exitsubshell false
shell...
something went wrong

Notes

• Parameterized to allow the if test to be true or false (see the 2 runs)


• When the if test is false, we never reach the subshell.

(Bash specific answer)
Bash has no concept of exceptions.
However, with set -o errexit (or the equivalent: set -e) at the outermost level, the failed command will result in the subshell exiting with a non-zero exit status.
If this is a set of nested subshells without conditionals around the execution of those subshells, it will effectively 'roll up' the entire script and exit.

This can be tricky when trying to include bits of various bash code into a larger script. One chunk of bash may work just fine on its own, but when executed under errexit (or without errexit), behave in unexpected ways.

[192.168.13.16 (f0f5e19e) ~ 22:58:22]# bash -o errexit /tmp/foo
something went wrong
[192.168.13.16 (f0f5e19e) ~ 22:58:31]# bash /tmp/foo
something went wrong
But we got here anyways
[192.168.13.16 (f0f5e19e) ~ 22:58:37]# cat /tmp/foo
#!/bin/bash
stop () 
 echo "$1"
 exit 1


if false; then
 echo "foo"
else
 (
 stop "something went wrong"
 )
 echo "But we got here anyways"
fi
[192.168.13.16 (f0f5e19e) ~ 22:58:40]#

My example to exit in one liner:

COMAND || ( echo "ERROR – executing COMAND, exiting..." ; exit 77 );[ "$?" -eq 77 ] && exit