The bracket expression "[...]" in Bourne shells

In traditional Bourne shells you'll find two variations about the matching with the expression "[...]", especially if a '-' is contained.

The manpage usually reads like the following:

 "[...] Matches any one of the enclosed characters. A pair of
        characters separated by - matches any character lexi-
        cally between the pair, inclusive."

This definition is very terse. Neither does it mention whether it's legal to use brackets as range delimiters, nor does it explain how to match a literal '-' itself.

The behaviour for the parts remaining undefined was modified with the SVR3 variant, albeit the exact behaviour even then still wasn't documented.

Why was it changed? In practice you certainly might be tempted to make usage of the undefined ways, too. And it does make sense having a state machine in mind: Matching two characters, one of them being a dash, doesn't strictly indicate a range. Also, a second opening bracket clearly may be part of a range (as ranges cannot be nested).

For robustness, you might stay with the documented (and portable) way. The following text in contrast deals with the undefined behaviour.

It's also not documented that both variants not only recognize the ranges - but the complete, literal string itself (with dash and outer brackets) will always match, too. This fact is not mentioned anymore in the following.

Here are the possible variations:

It's safe to use [ inside [...] as this construct cannot be nested and the shell internally only searches for the closing bracket.
Note that using [ in a range is closely related with using it literally, [[].

• "[X-[]", as if a range were finished with [,
  • seems legal, both variants treat this like a range from X to [.
• "[[-x]", as if a range were started with [,
  • seems legal, both variants treat this like a range from [ to x.

The next two in contrast are very ambiguous:

• "[X-]]", as if a range were finished with ],
  • the modern variant treats this like a collection of X and - with a bracket appended: X] and -] are matched.
  • the old variant treats this exactly like a range from X to ].
• "[]-x]", as if a range were started with ],
  • the modern variant usually treats this like a range from ] to x.
    Exceptions are SunOS 4 and OSF1/V4 ff.
  • in the old variant this does not match anything.

• "[-X]", the - is at the beginning,
  • the modern variant treats this as a collection of - and X.
  • in the old variant this usually matches X but not -.
    One exception is on AIX 3, where it doesn't match anything.
• "[X-]", the - is at the end,
  • the modern variant treats this like a collection of X and - .
  • in the old variant this matches neither X nor -.

So the modern variant was introduced to behave more intuitive. One might just consider it a bugfix.

What about other shells?

• ksh88 and ksh93 behave exactly like the modern variant.
• bash-1, bash-2, pdksh-5.2.14, zsh-3.0.8 and zsh-4.0.6 behave like the modern variant,
  with one exception: the complete, literal strings themselves are not matched.
• bash-2 ff. and zsh-3.0.8 reject the very first of the examples above ("[X-[]").