[libcxx] Handle invalid escaped characters in POSIX regex

[miyuki]

Summary

Currently when parsing basic and extended POSIX regular expressions
libc++ silently skips invalid escaped characters and trailing escapes.
This patch changes the behavior, so that a std::regex_error with code
set to error_escape is thrown in these cases.
The patch also extends the bad_escape test case to document the
expected behavior for commonly used escape sequences.

[mclow.lists]

I like this. One nit and a question.

include/regex

3492–3493

Do we need any more cases here?

test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp

50

should be const. (Yes, this is me being picky)

[• Quuxplusone]

include/regex

3465

FWIW, I don't understand what's going on in this switch.
Is it intentional that '(' and '|' now take different paths here?

test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp

60

I would think about adding test cases here to document the intended behavior of

• "\\n" and "\\t" which are valid of course;
• "\\\n" which could be a common typo and should probably throw;
• "\\/" which is common in Perl but maybe should throw anyway;
• "\\1" in a regex mode that doesn't support backreferences;
• "\\0".

If these are already covered elsewhere in the suite, then never mind me.

[miyuki]

include/regex

3465

Yes. As far as I understand, only extended POSIX regular expressions support alternation: http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html, so "\\|" should be treated as error_escape

[miyuki]

Updated __parse_QUOTED_CHAR_ERE. Added more test cases.

[miyuki]

include/regex

3492–3493

Probably not, but we should throw an exception here as well.

[miyuki]

ping

include/regex

 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR(_ForwardIterator __first,
                                                   _ForwardIterator __last)
 {
     if (__first != __last)
     {
-        _ForwardIterator __temp = _VSTD::next(__first);
-        if (__temp != __last)
-        {
-            if (*__first == '\\')
-            {
-                switch (*__temp)
-                {
-                case '^':
-                case '.':
-                case '*':
-                case '[':
-                case '$':
-                case '\\':
-                    __push_char(*__temp);
-                    __first = ++__temp;
-                    break;
-                }
+            _ForwardIterator __temp = _VSTD::next(__first);
+            if (__temp == __last)
+                __throw_regex_error<regex_constants::error_escape>();
+
+            case '(':
+            case ')':
+            case '{':
+            case '}':
+                break;
+            default:
+                if (*__temp >= '1' && *__temp <= '9')
+                    break;
+                __throw_regex_error<regex_constants::error_escape>();
             }
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR_ERE(_ForwardIterator __first,
                                                       _ForwardIterator __last)
 {
     if (__first != __last)
     {
-        _ForwardIterator __temp = _VSTD::next(__first);
-        if (__temp != __last)
-        {
-            if (*__first == '\\')
-            {
-                switch (*__temp)
-                {
-                case '^':
-                case '.':
-                case '*':
-                case '[':
-                case '$':
-                case '\\':
-                case '(':
-                case ')':
-                case '|':
-                case '+':
-                case '?':
-                case '{':
-                case '}':
-                    __push_char(*__temp);
-                    __first = ++__temp;
-                    break;
-                default:
-                    if ((__flags_ & 0x1F0) == awk)
-                        __first = __parse_awk_escape(++__first, __last);
+            _ForwardIterator __temp = _VSTD::next(__first);
+            if (__temp == __last)
+                __throw_regex_error<regex_constants::error_escape>();
+
+                if ((__flags_ & 0x1F0) == awk) {
                     break;
                 }
+                __throw_regex_error<regex_constants::error_escape>();
             }
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>

test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp

 
 // template <class ST, class SA>
 //    basic_regex(const basic_string<charT, ST, SA>& s);
 
 #include <regex>
 #include <cassert>
 #include "test_macros.h"
 
-static bool error_escape_thrown(const char *pat)
+static bool error_escape_thrown(const char *pat,
+                                std::regex_constants::syntax_option_type
+                                    syntax = std::regex_constants::ECMAScript)
 {
     bool result = false;
     try {
-        std::regex re(pat);
+        std::regex re(pat, syntax);
     } catch (const std::regex_error &ex) {
         result = (ex.code() == std::regex_constants::error_escape);
     }
     return result;
 }
 
 int main()
 {
     assert(error_escape_thrown("[\\a]"));
     assert(error_escape_thrown("\\a"));
     assert(error_escape_thrown("\\"));
 
     assert(error_escape_thrown("[\\e]"));
     assert(error_escape_thrown("\\e"));
 
     assert(error_escape_thrown("[\\c:]"));
     assert(error_escape_thrown("\\c:"));
     assert(error_escape_thrown("\\c"));
     assert(!error_escape_thrown("[\\cA]"));
     assert(!error_escape_thrown("\\cA"));
 
+    const std::regex_constants::syntax_option_type basic =
+        std::regex_constants::basic;
+
+    assert(error_escape_thrown("\\a", basic));
+    assert(error_escape_thrown("\\n", basic));
+    assert(error_escape_thrown("\\t", basic));
+    assert(error_escape_thrown("\\0", basic));
+    assert(error_escape_thrown("\\/", basic));
+    assert(error_escape_thrown("\\\n", basic));
+    assert(error_escape_thrown("\\", basic));
+
+    assert(!error_escape_thrown("[\\a]", basic));
+    assert(!error_escape_thrown("\\(a\\)", basic));
+    assert(!error_escape_thrown("\\(ab\\)\\1", basic));
+    assert(!error_escape_thrown("a\\{1,2\\}", basic));
+    assert(!error_escape_thrown("\\.", basic));
+    assert(!error_escape_thrown("\\*", basic));
+
+    const std::regex_constants::syntax_option_type extended =
+        std::regex_constants::extended;
+
+    assert(error_escape_thrown("\\a", extended));
+    assert(error_escape_thrown("\\n", extended));
+    assert(error_escape_thrown("\\t", extended));
+    assert(error_escape_thrown("\\0", extended));
+    assert(error_escape_thrown("(ab)\\1", extended));
+    assert(error_escape_thrown("\\/", extended));
+    assert(error_escape_thrown("\\\n", extended));
+    assert(error_escape_thrown("\\", extended));
+
+    assert(!error_escape_thrown("[\\a]", extended));
+    assert(!error_escape_thrown("\\(a\\)", extended));
+    assert(!error_escape_thrown("\\{\\}", extended));
+    assert(!error_escape_thrown("\\.", extended));
+    assert(!error_escape_thrown("\\*", extended));
+
+    const std::regex_constants::syntax_option_type awk =
+        std::regex_constants::awk;
+
+    assert(error_escape_thrown("\\z", awk));
+    assert(error_escape_thrown("[\\z]", awk));
+    assert(error_escape_thrown("\\9", awk));
+    assert(error_escape_thrown("\\\n", awk));
+    assert(error_escape_thrown("\\", awk));
+
+    assert(!error_escape_thrown("\\n", awk));
+    assert(!error_escape_thrown("\\t", awk));
+    assert(!error_escape_thrown("\\/", awk));
+    assert(!error_escape_thrown("\\(a\\)", awk));
+    assert(!error_escape_thrown("\\{\\}", awk));
+    assert(!error_escape_thrown("\\0", awk));
+    assert(!error_escape_thrown("\\1", awk));
+    assert(!error_escape_thrown("\\.", awk));
+    assert(!error_escape_thrown("\\*", awk));
 }