Chapter 9. Debugging Shell Programs

9.1.2.1. EXIT

The EXIT trap, when set, runs its code when the function or script within which it was set exits. Here's a simple example:

function func {
    trap 'print "exiting from the function"' EXIT
    print 'start of the function'
}

trap 'print "exiting from the script"' EXIT
print 'start of the script'
func

If you run this script, you see this output:

start of the script
start of the function
exiting from the function
exiting from the script

In other words, the script starts by setting the trap for its own exit. Then it prints a message and finally calls the function. The function does the same -- sets a trap for its exit and prints a message. (Remember that function-style functions can have their own local traps that supersede any traps set by the surrounding script, while POSIX functions share traps with the main script.)

The function then exits, which causes the shell to send it the fake signal EXIT, which in turn runs the code print "exiting from the function". Then the script exits, and its own EXIT trap code is run. Note also that traps "stack;" the EXIT fake signal is sent to each running function in turn as each more recently called function exits.

An EXIT trap occurs no matter how the script or function exits, whether normally (by finishing the last statement), by an explicit exit or return statement, or by receiving a "real" signal such as INT or TERM. Consider the following inane number-guessing program:

trap 'print "Thank you for playing!"' EXIT

magicnum=$(($RANDOM%10+1))
print 'Guess a number between 1 and 10:'
while read guess'?number> '; do
    sleep 10
    if (( $guess == $magicnum )); then
        print 'Right!'
        exit
    fi
    print 'Wrong!'
done

9.1.2.2. ERR

A simple but effective use of this is to put the following code into a script you want to debug:

function errtrap {
    typeset es=$?
    print "ERROR: Command exited with status $es."
}

trap errtrap ERR

The first line saves the nonzero exit status in the local variable es.

For example, if the shell can't find a command, it returns status 1. If you put the code in a script with a line of gibberish (like "lskdjfafd"), the shell responds with:

scriptname: line N: lskdjfafd:  not found
ERROR: command exited with status 1.

N is the number of the line in the script that contains the bad command. In this case, the shell prints the line number as part of its own error-reporting mechanism, since the error was a command that the shell could not find. But if the nonzero exit status comes from another program, the shell doesn't report the line number. For example:

function errtrap {
    typeset es=$?
    print "ERROR: Command exited with status $es."
}

trap errtrap ERR

function bad {
    return 17
}

bad

This only prints ERROR: Command exited with status 17.

To get around this problem, we simply pass $LINENO as an argument to the trap handler, surrounding it in single quotes so that it doesn't get evaluated until the fake signal actually comes in:

function errtrap {
    typeset es=$?
    print "ERROR line $1: Command exited with status $es."
}
trap 'errtrap $LINENO' ERR
...

If you use this with the above example, the result is the message, ERROR line 12: Command exited with status 17. This is much more useful. We'll see a variation on this technique shortly.

This simple code is actually not a bad all-purpose debugging mechanism. It takes into account that a nonzero exit status does not necessarily indicate an undesirable condition or event: remember that every control construct with a conditional (if, while, etc.) uses a nonzero exit status to mean "false." Accordingly, the shell doesn't generate ERR traps when statements or expressions in the "condition" parts of control structures produce nonzero exit statuses.

9.1.2.3. DEBUG

For example, you notice that the value of a particular variable is running amok. The naive approach would be to put in lots of print statements to check the variable's value at several points. The DEBUG trap makes this easier:

function dbgtrap {
    print "badvar is $badvar"
}

trap dbgtrap DEBUG

... Section of code in which problem occurs ...

trap - DEBUG            # turn off DEBUG trap

This code prints the value of the wayward variable before every statement between the two traps.