Sstrhsrtj

So I have a shell script that does some preparation and then runs a utility.

The preparation can be affected by switches like -a or -n. The contents of the command line that are not such switches are to be passed to the utility. Currently my script has:

while getopts ":an" opt; do

  case $opt in

    a)

      #something

      ;;

    n)

      #something else

      ;;

    ?)

      echo "Invalid option: -$OPTARG" >&2

      ;;

  esac

done

shift $((OPTIND-1))

  #more prep

my_utility $@

However, this fails when I want to pass long-form options to the utility, such as --abc as that is interpreted as a, b, and c options by getopts.

So how can I process options in such a way that -a or -n is processed, but --abc remains untouched? Unless, of course, I dump Shell and do it in Python - then options would be very easy, but I also need to copy files and run utilities, and Python makes this awkward.

I don't see why you couldn't simulate long options by treating - as a short option requiring an argument:

$ cat /tmp/foo

while getopts :aq:-: opt; do

        case $opt in

        a)      echo option -a;;

        q)      echo option -q with value "$OPTARG";;

        -)      case $OPTARG in

                abc)    echo option --abc;;

                def=*)  echo option --def with value "${OPTARG#*=}";;

                *)      echo >&2 "unknown option --$OPTARG";;

                esac;;

        :)      echo >&2 "-$OPTARG needs an argument";;

        *)      echo >&2 "unknown option -$OPTARG";;

        esac

done

shift "$((OPTIND - 1))"

echo argv: "$@"



$ sh /tmp/foo -a -qt --abc --def=ghi -- foo bar

option -a

option -q with value t

option --abc

option --def with value ghi

argv: foo bar

Of course, instead of echo'ing you could append them to a command line:

cmd=whatever

while getopts ...; do

         ...

         abc) cmd="$cmd --abc";;

         ...

done

shift "$((OPTIND - 1))"

eval "$cmd "$@""

To interpret double dash commands you need GNU's getopt instead of the built-in getopts.

There is a way to use the bash builtin getopts to mimic long options, but you should not do that as it's a kludge and not worth your effort as getopts cannot enforce the long specification.

So your script becomes:

#!/bin/bash



# Get options

OPTS=`getopt --options an: --long a_something,n_something_else: -n 'parse-options' -- "$@"`



if [ $? != 0 ] ; then echo "Failed parsing options." >&2 ; exit 1 ; fi



#echo parsed and cleaned up options

echo "$OPTS"

eval set -- "$OPTS"



bSomething=false

bSomethingElse=false



# "Endless" loop over the parsed options

while true; do

  case "$1" in

    -a | --a_something )       bSomething=true;     shift ;;

    -n | --n_something_else )  bSomethingElse=true; shift ;;

    -- )                                            shift; break ;;

    * )                                                    break ;;

  esac

done

For more information: man getopt

For even more information: man getopt(3)