Separating arguments from options

It is necessary to distinguish options from arguments, to be able to use arguments with leading dashes.
Nowadays, this is usually achieved by using -- as delimiter (set -e -- -arg1 -arg2).

Yet, this is frequently seen with a single dash as delimiter. Why?

set -- was not implemented originally, but came with the second release of the Bourne shell. Apparently, it gets confused since then.

• Version 7 ('69)
  • The shell doesn't know --, yet. You would receive "bad option(s)" instead.

  • But even - is not intended to terminate options.
    The purpose is to turn off especially -x and -v and it is documented as such.
    In fact, + to turn off an option is not implemented, yet, either.

  • Traditional Bourne shells don't accept options separated (set -e -u), but only combined (set -eu).
    So that's why you can abuse - to set arguments with leading dashes:

        set - -argument

    Note: If -x or -v had been active before, you would have to set them again now.

  • "#!/bin/sh -" works the same way. But you even wouldn't notice the abuse,
    because it's not in the middle of a script where options could have been set earlier.

  • There's even a bug:
    Wrongly, the reset of -x and -v is not only triggered by "-" but by the leading dash in any option,
    because the check for a terminating \0 is missing. See the endnote for the code.
    Thus you even have to set -x or -v a second time, if you have set any other option after the first time.

• System III ('71)
  • System III introduces "--" to explicitly end options.
    Thus, set now works correct, e.g., set -eu -- -firstargument.

  • The bug from above (recognizing any option also as "-") is also gone. See the endnote for code.

  • System III also introduces + to turn off a respective option.

  • The behaviour for a single "-" to turn off -x and -v is not documented anymore. However, it remains unchanged in the code.
    This is either an accident, because due to the implementation of +, this feature has become useless. Or it remains active for backwards compatibility only.

  • Thus "#!/bin/sh -" still works.
    The correct way rather is "#!/bin/sh --"
    Apparently this was often missed then, perhaps due to the abovementioned confusions.
    After all, at times a single dash seems to be used until today.

• Solaris
  • Ironically, there's an error in the Solaris manual about "--" since SunOS 5.7.
    One dash in the description got lost and now it tells that "-" does not change any of the flags.
    This error also might have slipped through, because "-" still can be abused this way.

At the beginning of some scripts you will see an equivalent to set --,

"#!/bin/sh --" or "#!/bin/sh -".

This fixes a security hole. The problem is as follows

• create a script with #!/bin/sh as first line
• create a symbolic link "./-i" to this script
• add the empty argument to your PATH, e.g. PATH=$PATH:
• execute "-i"

If the script doesn't force end of options, you will get an interactive shell:
The kernel starts the the interpreter with the script as argument, which is -i.

Be aware, that your shell might change the path from -i to ./-i, like bash does (all releases).
Bourne, Korn and Almquist shells, pdksh (and its derivatives) keep the path.

By the way, there's an alternative to set --, you could use a dummy and shift it away:

    set -options dummy arguments; shift

Modern bourne compatible shells allow to unset the parameter list this way.
However, in the traditional Bourne shell this doesn't change anything.
Alternatively, you can either shift until there are no parameters left,

    while shift 2>/dev/null; do :; done

or similar to the abovementioned workaround

    set -options dummy; shift

The following was released under the license of Caldera.

Version 7

    INT     options(argc,argv)
	    STRING          *argv;
	    INT             argc;
    {
	    REG STRING      cp;
	    REG STRING      *argp=argv;
	    REG STRING      flagc;
	    STRING          flagp;


	    IF argc>1 ANDF *argp[1]=='-'
	    THEN    cp=argp[1];
		    flags &= ~(execpr|readpr);
		    WHILE *++cp
		    DO      [...]

System III

    INT     options(argc,argv)
	    STRING          *argv;
	    INT             argc;
    {
	    REG STRING      cp;
	    REG STRING      *argp=argv;
	    REG STRING      flagc;
	    STRING          flagp;

	    IF argc>1 ANDF *argp[1]=='-'
	    THEN
		    IF argp[1][1] == '-'
		    THEN    /* if first argument is "--" then options are not
			       to be changed        Fix for problems getting
			       $1 starting with a "-"
			    */
			    argp[1] = argp[0]; argc--;
			    return(argc);
		    FI
		    cp = argp[1];
		    IF cp[1] == '\0' THEN flags &= ~(execpr|readpr) FI
		    /* Step along 'flagchar[]' looking for matches.
		       'sicr' are not legal with 'set' command.
		    */
		    WHILE *++cp
		    DO      flagc=flagchar;