GNU C Arg Parser - options with required arguments are parsed wrongly?

Question

I'm learning GNU C Arg Parser and it parses options with required arguments in a strange way. 

Consider this example from the documentation: https://www.gnu.org/software/libc/manual/html_node/Argp-Example-3.html

$./a --help       
Usage: a [OPTION...] ARG1 ARG2
Argp example #3 -- a program with options and arguments using argp

 -o, --output=FILE          Output to FILE instead of standard output
 -q, -s, --quiet, --silent  Don't produce any output
 -v, --verbose              Produce verbose output
 -?, --help                 Give this help list
     --usage                Give a short usage message
 -V, --version              Print program version

-o / --output requires argument FILE.

Now, if you omit FILE and put the next option behind it, like this

./a -o -v arg1 arg2
ARG1 = arg1
ARG2 = arg2
OUTPUT_FILE = -v
VERBOSE = no
SILENT = no

it will take -v as FILE. I would expect the above command to fail because there was no option for -o. -v should be IMHO considered to be the next option and not the argument for -o. 

Is this a bug or am I missing something?

Consider this similar code in Python:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--foo', help='foo help')
args = parser.parse_args()

If I execute python3 a.py --foo -h, it will recognize that the mandatory argument for --foo is missing and it will not take -h as an argument for --foo.

python3 a.py --foo -h
usage: a.py [-h] [--foo FOO]
a.py: error: argument --foo: expected one argument

I would expect that GNU Arg Parse should behave the same but it does not. Is GNU Arg Parse buggy?

Answer 1

The -o option must accept whatever comes after it, because a file could have any kind of name. There could actually be a file named -v. Other options that take an argument may have similar reasons for taking any arbitrary string. There's no good reason for excluding certain strings from being option arguments.

Your Python example uses a long option, which might require an = sign for its argument. I'll have to do some digging to see if the behavior is actually different between C and Python. I doubt it has anything to do with the next argument starting with a dash.

EDIT: I'm surprised to find that Python does reject option arguments that start with a dash, unless we use the long option with =. In my opinion, this makes it hard to pass arbitrary strings, and makes the command-line syntax more complicated than it needs to be. I don't think it's safe to assume the user made a mistake, especially when the arg parser library has no way of knowing what the option actually means. Here's my Python code:

from argparse import ArgumentParser

ap = ArgumentParser()
ap.add_argument('-f', '--foo')


def tryArgs(args):
    try:
        print(ap.parse_args(args).foo)
    except SystemExit:
        print(args)


# These work
tryArgs(('-f', 'hi'))
tryArgs(('--foo', 'hi'))
tryArgs(('--foo=-a',))

# Doesn't work, even if '-a' is not an existing option
tryArgs(('-f', '-a'))
# Still doesn't work
tryArgs(('--foo', '-a'))
# We get the same error even if we try to use '--' to declare all arguments as
# non-options.
tryArgs(('-f', '--', '-a'))

Output:

hi
hi
-a
usage: python.py [-h] [-f FOO]
python.py: error: argument -f/--foo: expected one argument
('-f', '-a')
usage: python.py [-h] [-f FOO]
python.py: error: argument -f/--foo: expected one argument
('--foo', '-a')
usage: python.py [-h] [-f FOO]
python.py: error: argument -f/--foo: expected one argument
('-f', '--', '-a')

For comparison, here is a similar C program. All the test arguments run without errors:

#include <argp.h>

static struct argp_option options[] = {
  {"foo", 'f', "FOO", 0, "Foosify the specified FOO", 0},
  {0},
};

static error_t
parser(int key, char *arg, __attribute__((unused)) struct argp_state *state)
{
  if (key == 'f') {
    printf("foo is %s\n", arg);
    return 0;
  }
  return ARGP_ERR_UNKNOWN;
}

static struct argp ap = {options, parser, NULL, NULL, NULL, NULL, NULL};

static void
tryArgs(int argc, char **argv)
{
  argp_parse(&ap, argc, argv, ARGP_NO_EXIT, NULL, NULL);
}

int
main(void)
{
  char *testArgs[][3] = {
    {"", "-f", "-?"},
    {"", "-f", "--help"},
    {"", "--foo", "-?"},
  };
  tryArgs(3, testArgs[0]);
  tryArgs(3, testArgs[1]);
  tryArgs(3, testArgs[2]);
}