Cfrtjryk

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.

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+=("$@")

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 "%sn" "${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. :)

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

}