AWK script shebang to allow dash-prefixed arguments - shell

Question

I wanted to write a fairly complex AWK script, which would take a bunch of command-line arguments, parse them and then perform some work.
Unfortunately I ran into trouble trying to pass dash-prefixed (-arg) arguments to the script, as they are being interpreted by AWK instead.
$ ./script.awk -arg
awk: not an option: -arg
I noticed the -- option, but I am unsure how to use it in the shebang meaningfully. I was unable to find any way to get the name of the file and reference it in the script's shebang (something like #!/usr/bin/awk -f $FILE --).
Then I thought maybe the -W exec option could be used to solve the issue, but I keep getting the following error (even without attempting to use the -- option with it), which seems to suggest that the name of the file is not even really being appended to the end of the shebang command.
$ ./script.awk
awk: vacuous option: -W exec
awk: 1: unexpected character '.'
Is there a way to make a standalone (single file, no wrapper script) executable AWK script, which can accept dash-prefixed arguments?
Why am I trying to abuse AWK to this extent? Mostly out of curiosity, but also to get rid of the wrapper shell script, which I currently have to use just to execute the AWK script:
#!/bin/sh
awk -f script.awk -- "$#"
The solution should be POSIX-compliant (assuming AWK's path is /usr/bin/awk). Even if you have a non-POSIX-compliant solution, please share it as well.

Answer 1

Understanding the problem:
As far as I understand, the OP has a complex script called script.awk:
#!/usr/bin/awk -f
BEGIN{print "ARGC", ARGC; for(i=0;i<ARGC;++i) print "ARG"i,ARGV[i]}
which the OP would like to call using various traditional POSIX-style one letter options, or GNU-style long options. POSIX options start with a single <hyphen>-character (-) while long options start with a two <hyphen>-characters (--). This, however, fails as awk is interpreting these arguments to be passed on to awk itself and not to the scripts argument list. Eg.
$ ./script.awk
ARGC 1
ARG0 awk
$ ./script.awk -arg
awk: not an option: -arg
Question: Is there a way to write a POSIX compliant script which can handle such hyphenated arguments? (Suggestions are made in the original question.)
Observation 1: While not immediately clear, it must be mentioned that the error message is generated by mawk and not the more common GNU version gawk. Where mawk fails, gawk does not:
$ mawk -f script.awk -arg
mawk: not an option -arg
$ gawk -f script.awk -arg
ARGC 2
ARG0 gawk
ARG1 -arg
Nonetheless, it must be mentioned that for both gawk and mawk, different behavriour can be observed when the arguments clash with the optional arguments of awk. Example:
$ mawk -f script.awk -var # this fails as gawk expects -v ar=foo
mawk: improper assignment: -v ar
$ gawk -f script.awk -var # this fails as gawk expects -v ar=foo
gawk: `oo' argument to `-v' not in `var=value' form
$ gawk -f script.awk -var=1 # this works and creates variable ar
$ mawk -f script.awk -var=1 # this works and creates variable ar
$ mawk -f script.awk -foo # this fails as it expects a file oo
mawk: cannot open oo (No such file or directory)
$ gawk -f script.awk -foo # this fails as it expects a file oo
gawk: fatal: can't open source file `oo' for reading (No such file or directory)
Observation 2: The OP suggests the usage of a double-<hyphen> to indicate that the consecutive options are only part of awk. This, however, is an extension of both mawk and gawk and not part of the POSIX standard.
--: indicates the unambiguous end of options. source: man mawk
--: Signal the end of options. This is useful to allow further arguments to the AWK program itself to start with a -. This provides consistency with the argument parsing convention used by most other POSIX programs. source: man gawk
Furthermore, the usage of the double-hyphen assumes that all arguments after -- are files:
$ ./script.awk -- -arg1 file
ARGC 3
ARG0 mawk
ARG1 -arg1
ARG2 file
mawk: cannot open -arg1 (No such file or directory)
Suggestion 1: While the concept of flags are a nice-to-have, you might consider making use of the standard POSIX compliant assignment as arguments:
$ ./script.awk arg1=1 arg2=1 arg3=1 file
However, the downside of this is that these assignments are only processed after the BEGIN block is executed. (cfr. POSIX standard)
Suggestion 2: a simple improvement would be to make use of ARGV and ARGC and use hyphen-less arguments. This is a bit more BSD-like (cfr ps aux), and could look like:
$ ./script.awk arg1 arg2 arg3
ARGC 4
ARG0 gawk
ARG1 arg1
ARG2 arg2
ARG3 arg3
Suggestion 3: If none of the above options are up to your liking, you have to consider using a hybrid between sh and awk. The word hybrid implies we write syntax that is recognized by both sh and awk. An awk program is composed of pairs of the form:
pattern { action }
where pattern can be ignored. This resembles closely the compound command syntax of sh:
{ compound-list ; }
This allows us now to write the following shell script script.sh:
#!/bin/sh
{ "awk" "-f" "$0" "--" "${#}" ; "exit" ;}
# your awk script comes here
By writing it this way, awk will interpret the first action as nothing more than a concatenation of strings. sh on the other hand will execute it nominally.
Sadly, while it looks promising, this does NOT work due to the effect of the double hyphen.
$ ./script.sh file # this works
ARGC 2
ARG0 awk
ARG1 file
$ ./script.sh -arg file # this does not work
ARGC 3
ARG0 mawk
ARG1 -arg1
ARG2 file
mawk: cannot open -arg1 (No such file or directory)
An ugly solution could be by starting to parse the script itself in itself to remove the first two lines before passing it back to awk. But this will only solve the problem for scripts only having a BEGIN block.