An atexit for Bash

Question

I wrote the following atexit implementation for Bash

#! /bin/bash

set -e

ATEXIT=()

function atexit_handler
{
  local EXPR
  for EXPR in "${ATEXIT[@]}"; do
    echo "evaluating $EXPR"
    eval "$EXPR" || true
  done
}

trap atexit_handler EXIT

function atexit ()
{
  local EXPR
  for EXPR in "$@"; do
    ATEXIT+=("$EXPR")
  done
}

atexit true
atexit false
atexit "echo bye"

false

I am wondering, if this is possible without the use of eval.

Answer 1

I don't think it's possible without the eval. A close candidate might be:

atexit_handler() {
  local EXPR
  for EXPR in "${ATEXIT[@]}"; do
    echo "evaluating $EXPR"
    $EXPR || true
  done
}

But this won't work with non-trivial expressions like this:

atexit 'for i in "a b" c; do echo $i; done'

---

Using the function keyword in function declaration like this is an outdated practice:

function atexit_handler
{
  local EXPR
  for EXPR in "${ATEXIT[@]}"; do
    echo "evaluating $EXPR"
    eval "$EXPR" || true
  done
}

Use the more modern style I wrote in the previous example above.

---

Instead of this:

  for EXPR in "$@"; do
    ATEXIT+=("$EXPR")
  done

A simpler way to iterate over $@:

  for EXPR; do
    ATEXIT+=("$EXPR")
  done

But actually, as @etan-reisner pointed out in a comment, it's silly to loop here when you can add the entire arg list in one swift move:

ATEXIT+=("$@")

Answer 2

Still uses eval, but it seems cleaner to do:

atexit() {
        cmd="$1"
        eval set -- $(trap -p EXIT)
        trap "$cmd; $3" EXIT
}

To allow semi-colons (eg, atexit "echo foo;") and aesthetic purity, you might like:

atexit() {
        cmd="${1%;}"
        eval set -- $(trap -p EXIT)
        trap "$cmd${3:+; }$3" EXIT
}

Answer 3

Sorry for excavating this, but just found it and wanted to try.

Will offer what I can.

#! /bin/bash

This is no crime, but it's a tad more portable (if that matters at all to you) if you use

#! /bin/env bash

env itself is virtually always in /bin, though some installations move the interpreter binaries.

I don't personally like or use set -e. It doesn't give me as much control over what happens. Personally, I prefer traps, something like this:

trap 'echo "ERROR $? at $0:$LINENO - [$BASH_COMMAND]"' err

Then I get useful feedback.

$: bogus
bash: bogus: command not found
ERROR 127 at /usr/bin/bash:73 - [bogus]

As for the eval, how about creating a controlled file to source at exit time?

atexit_handler() {
  tmp=$(mktemp)
  printf "%s\n" "${ATEXIT[@]}" >| $tmp
  trap 'echo "Error $? in exit handler when processing [$BASH_COMMAND]"' err
  . $tmp
}

This would allow for more arbitrarily complex possibilities, without really worsening the security risk of the eval, which isn't catastrophic if your code registers all the commands going into the handler anyway. It also leaves you the option of scheduling the cleanup of the file with the handler, so that if it succeeds it leaves no mess, but if it fails will abort and let you debug the file.

atexit true
atexit "echo bye"
atexit 'sing() { for i in do re me;do echo "$i"; done; }'
atexit sing
atexit false
atexit 'rm $tmp' # defer evaluation 

I love this idea, btw. I may start using it. :)