[FIX][libc++][Regex] Using regex_constants match_prev_avail | match_not_bol | match_not_bow

[dnsampaio]

Summary

pr42199
When using regex_constants::match_prev_avail, it is defined that
--first is valid, and match_not_bol and match_not_bow should be
ignored. At the moment these flags are not ignored. This fixis that.

[dnsampaio]

Ping.

[EricWF]

libcxx/test/std/re/re.const/re.matchflag/match_prev_avail.pass.cpp

16

Please fix the FIXME.

36

Why are these commented out?

[dnsampaio]

Hi @EricWF, thanks for the review.
Indeed there seems to have some other unrelated issue for matching the word boundary \b. Perhaps I wrongly assumed that it should also match line beginning and end.
For example, I would expect all these matches to succeed:

cout << regex_match("a", regex("\ba")) << "\n"
     << regex_match("a", regex("a\b")) << "\n"
     << regex_match("a", regex("\ba\b")) << "\n"
     << regex_match("a", regex("a")) << "\n";

But what I get is:

0
0
0
1

So it is unrelated in how match_not_bow is ignored when using match_prev_avail. I would rather open a defect for that apart.

[dnsampaio]

Ping.

[dnsampaio]

• Fixed tests to use "\\b" instead of "\b".

[dnsampaio]

Gentle Ping. I believe all issues with this fix have been fulfilled.

[dnsampaio]

Ping

[dnsampaio]

Ping

[dnsampaio]

Ping

[dnsampaio]

Ping. I would like to move along this small patch.

[miyuki]

The updated patch LGTM

[ldionne]

Thanks for your patience. I'm fine with this. @EricWF Please post-commit review this if you still have issues with it.

[ldionne]

@dnsampaio

This seems to have broken the ASAN bot. Could you please take a quick look?

http://lab.llvm.org:8011/builders/libcxx-libcxxabi-x86_64-linux-ubuntu-asan/builds/3207/steps/test.libcxx/logs/FAIL%3A%20libc%2B%2B%3A%3Amatch_prev_avail.pass.cpp

Also pasted at https://gist.github.com/ldionne/b85d28805bdf1550b0b59a96146f4b81 cause I don't know when the build bot logs go away.

[dnsampaio]

Hi, @ldionne
I just submitted a what I think is the test fix. It was the only place I was not using the second element of the string and could generate a underflow.

[ldionne]

In D75622#2014878, @dnsampaio wrote:

Hi, @ldionne
I just submitted a what I think is the test fix. It was the only place I was not using the second element of the string and could generate a underflow.

Thanks for taking a look!

libcxx/include/regex

 template <class _CharT, class _Traits>
 template <class _Allocator>
 bool
 basic_regex<_CharT, _Traits>::__search(
         const _CharT* __first, const _CharT* __last,
         match_results<const _CharT*, _Allocator>& __m,
         regex_constants::match_flag_type __flags) const
 {
+    if (__flags & regex_constants::match_prev_avail)
+        __flags &= ~(regex_constants::match_not_bol | regex_constants::match_not_bow);
+
     __m.__init(1 + mark_count(), __first, __last,
                                     __flags & regex_constants::__no_update_pos);
     if (__match_at_start(__first, __last, __m, __flags,
                                     !(__flags & regex_constants::__no_update_pos)))
     {
         __m.__prefix_.second = __m[0].first;
         __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;
         __m.__suffix_.first = __m[0].second;

libcxx/test/std/re/re.const/re.matchflag/match_prev_avail.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <regex>
+
+// match_prev_avail:
+//     --first is a valid iterator position. When this flag is set the flags
+//     match_not_bol and match_not_bow shall be ignored by the regular
+//     expression algorithms (30.11) and iterators (30.12)
+
+// FIXME: Some examples with word boundary '\b' are failing.
+// Even when not using match_prev_avail or match_not_bow
+
+#include <cassert>
+#include <regex>
+using namespace std;
+
+int main() {
+  char str1[] = "\na";
+  auto str1_scnd = str1 + 1;
+  // Assert that match_prev_avail disables match_not_bol and this matches
+  assert(regex_match(str1 + 1, str1 + 2, regex("^a"),
+                     regex_constants::match_not_bol |
+                         regex_constants::match_prev_avail));
+  // Manually passing match_prev_avail defines that --str1 is a valid position
+  assert(regex_match(str1_scnd, regex("a"),
+                     regex_constants::match_not_bol |
+                         regex_constants::match_prev_avail));
+
+  //Assert that match_prev_avail disables match_not_bow and this matches
+  //assert(regex_match(str1, regex(".*\ba")));
+  //assert(regex_match(str1 + 1, str1 + 2, regex("\ba\b"),
+  //                   regex_constants::match_not_bow |
+  //                   regex_constants::match_prev_avail));
+  // assert(regex_match(str1, regex("\ba"),
+  //                    regex_constants::match_not_bow |
+  //                    regex_constants::match_prev_avail));
+
+  //Assert that match_prev_avail disables both match_not_bow and match_not_bol
+  assert(regex_match(str1 + 1, str1 + 2, regex("^a"),
+                     regex_constants::match_not_bol |
+                         regex_constants::match_not_bow |
+                         regex_constants::match_prev_avail));
+  // assert(regex_match(str1, regex("\ba"),
+  //                         regex_constants::match_not_bol |
+  //                         regex_constants::match_not_bow |
+  //                         regex_constants::match_prev_avail));
+
+  // pr 42199
+  string S = " cd";
+  string::iterator Start = S.begin() + 1;
+  string::iterator End = S.end();
+  assert(regex_search(Start, End, regex("^cd")));
+
+  assert(
+      !regex_search(Start, End, regex("^cd"), regex_constants::match_not_bol));
+  assert(!regex_search(Start, End, regex(".*\bcd\b"),
+                       regex_constants::match_not_bow));
+  assert(!regex_search(Start, End, regex("^cd"),
+                       regex_constants::match_not_bol |
+                           regex_constants::match_not_bow));
+  assert(!regex_search(Start, End, regex(".*\bcd\b"),
+                       regex_constants::match_not_bol |
+                           regex_constants::match_not_bow));
+
+  assert(regex_search(Start, End, regex("^cd"),
+                      regex_constants::match_prev_avail));
+
+  assert(regex_search(Start, End, regex("^cd"),
+                      regex_constants::match_not_bol |
+                          regex_constants::match_prev_avail));
+  assert(regex_search(Start, End, regex("^cd"),
+                      regex_constants::match_not_bow |
+                          regex_constants::match_prev_avail));
+  // assert(regex_search(Start, End, regex (".*\bcd\b"), regex_constants::match_not_bol |
+  //                                regex_constants::match_not_bow |
+  //                                regex_constants::match_prev_avail));
+  return 0;
+}