Is the regex [b-a] legal?

[Alcaro]

#include <regex>

int main()
{
    try {
        std::regex r("[\\d-e]");
        puts("it's legal");
    } catch (std::exception& e) {
        puts(e.what());
    }
    try {
        std::regex r("[b-a]");
        puts("it's legal");
    } catch (std::exception& e) {
        puts(e.what());
    }
}

https://godbolt.org/z/oMvEr5YTs

Output: The expression contained an invalid character range, such as [b-a] in most encodings. and it's legal

Expected behavior: I'd expect that if I can produce an error saying that [b-a] is invalid, then an input of [b-a] returns that same error.

(Also, if you change it to [1-0], it's illegal in all encodings. The C and C++ specs demand that 0-9 are ascending and consecutive.)

[Rajveer100]

Considering:

• [\\d-e] is valid
• [b-a] is invalid

Among the three outputs, msvc seems most accurate. gcc is incorrect for the first one, whereas clang is incorrect for both.

[Alcaro]

The string [\\d-e] is a valid regex, with a character class containing the byte \ and the range d-e, yes. Nothing interesting here.

But that is not the string passed to std::regex. The compiler eats the first backslash, so the actual regex is [\d-e], meaning the range \d to e. Since \d doesn't represent exactly one character, that range makes no sense, and an error is expected; GCC is correct for both. (MS-STL interprets it as \d, and the literal characters - and e. libc++ seems to interpret [b-a] as matching nothing.)

[Rajveer100]

Hmm, so you mean the first case isn't the issue even though it has different behaviours?

Indeed, libc++ should definitely throw an error for the second one.

[Alcaro]

Yes, the first one is correct in libc++(*). I included it only because its error message directly names the second one.

I believe MS-STL accepting it is a bug on their end, but it's probably ossified into a vendor extension and a wontfix.

(*) to my knowledge - the C++ spec doesn't say which version of ECMA-262 it refers to, and there's at least two versions of the regex syntax in 262 (lookbehind only exists in newer versions). It would be surprising, but not impossible, for there to exist a version or two where the libc++ and/or MS-STL behavior is correct.

[pinskia]

Isn't this a dup of #51028

[ldionne]

Yes, I think that's a dupe indeed. Closing as a duplicate for now, please reopen if someone thinks that's incorrect.