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").

set -- was not implemented originally, though. Here are some parts of the history:

• Version 7
  • 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.
    The reason probably is: "+" to turn off an option is not implemented, yet.

  • Traditional 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

    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 code triggers not only for "-" but for the leading dash in any option,
    because the check for a terminating \0 is missing. See the endnote for the code.
    Thus you have to set -x or -v a second time, if you have set any other option after the first time.

• System III
  • 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.
    This is either an accident, because due to "+" this feature has become useless. Or it remains active in a hidden way only for backwards compatibility.

  • 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.

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.

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;