Revert of Update re2

third_party/re2/re2/testing/tester.cc

 // Copyright 2008 The RE2 Authors.  All Rights Reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Regular expression engine tester -- test all the implementations against each other.
 
 #include "util/util.h"
 #include "util/flags.h"
 #include "re2/testing/tester.h"
 #include "re2/prog.h"
@@ skipping 228 matching lines @@
   }
 
   // Compile regexp to RE.
   // PCRE as exposed by the RE interface isn't always usable.
   // 1. It disagrees about handling of empty-string reptitions
   //    like matching (a*)* against "b".  PCRE treats the (a*) as
   //    occurring once, while we treat it as occurring not at all.
   // 2. It treats $ as this weird thing meaning end of string
   //    or before the \n at the end of the string.
   // 3. It doesn't implement POSIX leftmost-longest matching.
-  // 4. It lets \s match vertical tab.
   // MimicsPCRE() detects 1 and 2.
   if ((Engines() & (1<<kEnginePCRE)) && regexp_->MimicsPCRE() &&
       kind_ != Prog::kLongestMatch) {
     PCRE_Options o;
     o.set_option(PCRE::UTF8);
     if (flags & Regexp::Latin1)
       o.set_option(PCRE::None);
     // PCRE has interface bug keeping us from finding $0, so
     // add one more layer of parens.
     re_ = new PCRE("("+re+")", o);
@@ skipping 77 matching lines @@
       result->matched =
         prog_->SearchDFA(text, context, anchor, kind_, result->submatch,
                          &result->skipped, NULL);
       // If anchored, no need for second run,
       // but do it anyway to find more bugs.
       if (result->matched) {
         if (!rprog_->SearchDFA(result->submatch[0], context,
                                Prog::kAnchored, Prog::kLongestMatch,
                                result->submatch,
                                &result->skipped, NULL)) {
-          LOG(ERROR) << "Reverse DFA inconsistency: "
-                     << CEscape(regexp_str_)
+          LOG(ERROR) << "Reverse DFA inconsistency: " << CEscape(regexp_str_)
                      << " on " << CEscape(text);
           result->matched = false;
         }
       }
       result->have_submatch0 = true;
       break;
 
     case kEngineOnePass:
       if (prog_ == NULL ||
           anchor == Prog::kUnanchored ||
@@ skipping 26 matching lines @@
       }
 
       RE2::Anchor re_anchor;
       if (anchor == Prog::kAnchored)
         re_anchor = RE2::ANCHOR_START;
       else
         re_anchor = RE2::UNANCHORED;
       if (kind_ == Prog::kFullMatch)
         re_anchor = RE2::ANCHOR_BOTH;
 
-      result->matched = re2_->Match(
-          context,
-          static_cast<int>(text.begin() - context.begin()),
-          static_cast<int>(text.end() - context.begin()),
-          re_anchor,
-          result->submatch,
-          nsubmatch);
+      result->matched = re2_->Match(context,
+                                    text.begin() - context.begin(),
+                                    text.end() - context.begin(),
+                                    re_anchor, result->submatch, nsubmatch);
       result->have_submatch = nsubmatch > 0;
       break;
     }
 
     case kEnginePCRE: {
       if (!re_ || text.begin() != context.begin() ||
           text.end() != context.end()) {
         result->skipped = true;
         break;
       }
-
-      // PCRE 8.34 or so started allowing vertical tab to match \s,
-      // following a change made in Perl 5.18. RE2 does not.
-      if ((regexp_str_.contains("\\s") || regexp_str_.contains("\\S")) &&
-          text.contains("\v")) {
-        result->skipped = true;
-        break;
-      }
 
       const PCRE::Arg **argptr = new const PCRE::Arg*[nsubmatch];
       PCRE::Arg *a = new PCRE::Arg[nsubmatch];
       for (int i = 0; i < nsubmatch; i++) {
         a[i] = PCRE::Arg(&result->submatch[i]);
         argptr[i] = &a[i];
       }
       int consumed;
       PCRE::Anchor pcre_anchor;
       if (anchor == Prog::kAnchored)
@@ skipping 81 matching lines @@
 
     Result r;
     RunSearch(i, text, context, anchor, &r);
     if (ResultOkay(r, correct)) {
       if (FLAGS_log_okay)
         LogMatch(r.skipped ? "Skipped: " : "Okay: ", i, text, context, anchor);
       continue;
     }
 
     // We disagree with PCRE on the meaning of some Unicode matches.
-    // In particular, we treat non-ASCII UTF-8 as non-word characters.
+    // In particular, we treat all non-ASCII UTF-8 as word characters.
     // We also treat "empty" character sets like [^\w\W] as being
     // impossible to match, while PCRE apparently excludes some code
     // points (e.g., 0x0080) from both \w and \W.
     if (i == kEnginePCRE && NonASCII(text))
       continue;
 
     if (!r.untrusted)
       all_okay = false;
 
     LogMatch(r.untrusted ? "(Untrusted) Mismatch: " : "Mismatch: ", i, text,
@@ skipping 66 matching lines @@
     for (int j = 0; j < arraysize(parse_modes); j++) {
       TestInstance* t = new TestInstance(regexp, kinds[i],
                                          parse_modes[j].parse_flags);
       error_ |= t->error();
       v_.push_back(t);
     }
   }
 }
 
 Tester::~Tester() {
-  for (size_t i = 0; i < v_.size(); i++)
+  for (int i = 0; i < v_.size(); i++)
     delete v_[i];
 }
 
 bool Tester::TestCase(const StringPiece& text, const StringPiece& context,
                          Prog::Anchor anchor) {
   bool okay = true;
-  for (size_t i = 0; i < v_.size(); i++)
+  for (int i = 0; i < v_.size(); i++)
     okay &= (!v_[i]->error() && v_[i]->RunCase(text, context, anchor));
   return okay;
 }
 
 static Prog::Anchor anchors[] = {
   Prog::kAnchored,
   Prog::kUnanchored
 };
 
 bool Tester::TestInput(const StringPiece& text) {
@@ skipping 18 matching lines @@
   return okay;
 }
 
 bool TestRegexpOnText(const StringPiece& regexp,
                       const StringPiece& text) {
   Tester t(regexp);
   return t.TestInput(text);
 }
 
 }  // namespace re2