Bash — parse flags and an expected (non-optional) argument

argumentsbashgetoptsshell-script

$ bash file.sh expected_arg -f optional_arg

I've seen posts that address using $1 to grab the first argument

and posts that address using getopts for parsing flag arguments. I haven't seen a post that addresses both.

I'm currently accessing expected_arg via $1.

I can't process the -f flag at all. Even though I also have this in my test script:

#!/bin/bash

dirname=$1

[[ -z  $dirname  ]] && echo "Project name required as an argument." && return

# get flags
verbose='false'
aflag='false'
bflag='false'
files='false'
while getopts 'abf:v' flag; do
  case "${flag}" in
    a) aflag='true' ;;
    b) bflag='true' ;;
    f) files="${OPTARG}" ;;
    v) verbose='true' ;;
    *) error "Unexpected option ${flag}" ;;
  esac
done

echo "$files"

echo "$HOME/Desktop/$dirname"

exit

The terminal shows:

Jills-MBP:~ jillr$ bash test.sh blah -f file
false
/Users/jillr/Desktop/blah

Unless I switch the order of the arguments, as in:

bash file.sh -f optional_arg expected_arg

Which the terminal outputs:

Jills-MBP:~ jillr$ bash test.sh -f file blah
file
/Users/jillr/Desktop/-f

So naturally, -f is processed as $1, which isn't what I want. I need to grab the expected_arg

Constraints needed:

I need to allow for a varying number of flags (from none at all to several). Therefore, the position of expected_arg will vary
expected_arg is a must
I would rather avoid having to use another flag in order to parse expected_arg (as in, I want to avoid doing something like $ bash test.sh -f file -d blah)

How can I satisfy those constraints?

Best Answer

Nevermind. I found this post: Using getopts to parse options after a non-option argument

which basically says I can solve my issue simply by placing shift after dirname=$1

Which will allows for entering the arguments as

$ bash file.sh expected_arg -f optional_arg

Related Solutions

Bash Getopts – Parsing Options After a Non-Option Argument

getopts starts parsing at the first argument and stops at the first non-option arguments. That's the standard convention — some GNU utilities accept options after arguments, but the normal thing is that in somecommand foo -bar qux, -bar is not parsed as an option.

If you want to start parsing options after bootstrap, you need to indicate that. getopts uses the OPTIND variable to remember what position it's at. OPTIND starts out with the value 1. To skip the first argument, set it to 2.

case "$1" in
   bootstrap)
      OPTIND=2
      while getopts ":b:" o; do
          …

Alternatively, you could shift the arguments that you've already processed.

subcommand=$1; shift
case "$subcommand" in
    bootstrap)
      while getopts ":b:" o; do
          …

Bash how to remove options from parameters after processing

POSIXly, the parsing for options should stop at -- or at the first non-option (or non-option-argument) argument whichever comes first. So in

cp -R file1 -t /mybackup file2 -f

that's at file1, so cp should recursively copy all of file1, -t, /mybackup and file2 into the -f directory.

GNU getopt(3) however (that GNU cp uses to parse options (and here you're using GNU cp since you're using the GNU-specific -t option)), unless the $POSIXLY_CORRECT environment variable is set, accepts options after arguments. So it is actually equivalent to POSIX option style parsing's:

cp -R -t /mybackup -f -- file1 file2

The getopts shell built-in, even in the GNU shell (bash) only handles the POSIX style. It also doesn't support long options or options with optional arguments.

If you want to parse the options the same way as GNU cp does, you'll need to use the GNU getopt(3) API. For that, if on Linux, you can use the enhanced getopt utility from util-linux (that enhanced version of the getopt command has also been ported to some other Unices like FreeBSD).

That getopt will rearrange the options in a canonical way which allows you to parse it simply with a while/case loop.

$ getopt -n "$0" -o t:Rf -- -Rf file1 -t/mybackup file2
 -R -f -t '/mybackup' -- 'file1' 'file2'

You'd typically use it as:

parsed_options=$(
  getopt -n "$0" -o t:Rf -- "$@"
) || exit
eval "set -- $parsed_options"
while [ "$#" -gt 0 ]; do
  case $1 in
    (-[Rf]) shift;;
    (-t) shift 2;;
    (--) shift; break;;
    (*) exit 1 # should never be reached.
  esac
done
echo "Now, the arguments are $*"

Also note that that getopt will parse options the same way as GNU cp does. In particular, it supports the long options (and entering them abbreviated) and honours the $POSIXLY_CORRECT environment variables (which when set disables support for options after arguments) the same way GNU cp does.

Note that using gdb and printing the arguments that getopt_long() receives can help building the parameters to getopt(1):

(gdb) bt
#0  getopt_long (argc=2, argv=0x7fffffffdae8, options=0x4171a6 "abdfHilLnprst:uvxPRS:T", long_options=0x417c20, opt_index=0x0) at getopt1.c:64
(gdb) set print pretty on
(gdb) p *long_options@40
$10 = {{
    name = 0x4171fb "archive",
    has_arg = 0,
    flag = 0x0,
    val = 97
  }, {
    name = 0x417203 "attributes-only",
[...]

Then you can use getopt as:

getopt -n cp -o abdfHilLnprst:uvxPRS:T -l archive... -- "$@"

Remember that GNU cp's list of supported options may change from one version to the next and that getopt will not be able to check if you pass a legal value to the --sparse option for instance.

Best Answer

Related Solutions

Bash Getopts – Parsing Options After a Non-Option Argument

Bash how to remove options from parameters after processing

Related Question