Using an environment variable to pass arguments to

Question

I'm trying to write a bash script that takes an environment variable and passes it along to a command.

So if I had something like:

export OUT="-a=arg1 -b=\"arg2.0 arg2.1\""

I want in my bash script to do something like:

<command> -a=arg1 '-b=arg2.0 arg2.1'

I have one approach that seems to do this, but it involves using eval:

eval <command> ${OUT}

If I include set -x right about the command, I will see:

+ eval <command> a=arg1 'b="arg2.0' 'arg2.1"'
++ <command> -a=arg1 '-b=arg2.0 arg.1'

However, I've poked around the dangers of using eval and since this will be taking the arguments from user input, it's less than ideal.

Since this is bash, I've also considered using arrays to store my arguments and simply put: <command> "$ARRAY[@]" to do what I want. I've been trying to use IFS, but I'm not sure what I should be splitting on.

Answer 1

For the simplified problem described in the answer above; i.e., turning the following environment variable into three arguments inside a bash script:

export OPTS="a=arg1 b=arg2.0 b=arg2.1"

Just do the following:

#!/bin/bash
opts=( $OPTS )
my-command "${opts[@]}"

# Use this for debugging:
echo "number of opts = ${#opts[@]}; opts are: ${opts[@]}"

Answer 2

If you're not completely inflexible about the format of $OUT, one possibility would be to repeat the option= string to allow for concatenation. Then you'd write:

export OUT="a=arg1 b=arg2.0 b=arg2.1"

If that is acceptable, the following script will work

#!/bin/bash

# Parse $OUT into an associative array.
# Instead of using $OUT, it would be cleaner to use "$@".
declare -A args
for arg in $OUT; do
  if [[ "$arg" =~ ^([[:alnum:]]+)=(.*)$ ]]; then
    key=${BASH_REMATCH[1]}
    val=${BASH_REMATCH[2]}
    if [[ -z ${args[$key]} ]]; then
      args[$key]=-$key="$val"
    else
      args[$key]+=" $val"
    fi
  fi
done

# Test, approximately as specified
command() { :; }
set -x
command "${args[@]}"
set +x

I can't say I like it much, but it's the closest I've been able to come.

Here's a sample run:

$ export OUT="a=foo b=bar  b=glitch s9= s9=* "
./command-runner
+ command -a=foo '-b=bar glitch' '-s9= *'
+ :
+ set +x

---

If you import a bash function (for example, in your bash startup file), you can make much better use of arrays. Here's one approach:

# This goes into your bash startup file:
declare -a SAVED_ARGS
save_args() {
  SAVED_ARGS=("$@")
}

do_script() {
  /path/to/script.sh "${SAVED_ARGS[@]}" "$@"
}

For expository purposes, script.sh:

#!/bin/bash
command() { :; }

set -x
command "${@/#/-}"
set +x

Example:

$ save_args x=3 y="a few words from our sponsor"
$ do_script a=3 b="arg2.0 arg2.1"
+ command -x=3 '-y=a few words from our sponsor' -a=3 '-b=arg2.0 arg2.1'
+ :
+ set +x
$ do_script a=42
+ command -x=3 '-y=a few words from our sponsor' -a=42
+ :
+ set +x

In case it's not obvious:

command() { :; }

defines a bash function called command which does almost nothing (except invoke the builtin : which does nothing), and

"${@/#/-}"

expands to the positional parameters, inserting a dash at the beginning of each one use a find-and-replace substitution. The pattern # is actually an empty pattern which only matches at the beginning of the string.