Migrate WebRequestRedirectByRegExAction to use RE2 and roll RE2 to revision 97:401ab4168e8e

third_party/re2/re2/compile.cc

 // Copyright 2007 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.
 
 // Compile regular expression to Prog.
 //
 // Prog and Inst are defined in prog.h.
 // This file's external interface is just Regexp::CompileToProg.
 // The Compiler class defined in this file is private.
 
@@ skipping 92 matching lines @@
 
 // Compiled program fragment.
 struct Frag {
   uint32 begin;
   PatchList end;
 
   Frag() : begin(0) { end.p = 0; }  // needed so Frag can go in vector
   Frag(uint32 begin, PatchList end) : begin(begin), end(end) {}
 };
 
-static Frag kNullFrag;
+static Frag NullFrag() {
+  return Frag();
+}
 
 // Input encodings.
 enum Encoding {
   kEncodingUTF8 = 1,  // UTF-8 (0-10FFFF)
   kEncodingLatin1,    // Latin1 (0-FF)
 };
 
 class Compiler : public Regexp::Walker<Frag> {
  public:
   explicit Compiler();
@@ skipping 457 matching lines @@
   // Four-byte
   {  4, 0x90, 0xBF, },  // 6:  90-BF 80-BF 80-BF
   {  6, 0xF0, 0xF0, },  // 7:  F0 90-BF 80-BF 80-BF*
   {  4, 0x80, 0xBF, },  // 8:  80-BF 80-BF 80-BF
   {  8, 0xF1, 0xF3, },  // 9: F1-F3 80-BF 80-BF 80-BF*
   {  4, 0x80, 0x8F, },  // 10: 80-8F 80-BF 80-BF
   { 10, 0xF4, 0xF4, },  // 11: F4 80-8F 80-BF 80-BF*
 };
 
 void Compiler::Add_80_10ffff() {
-  int inst[arraysize(prog_80_10ffff)];
+  int inst[arraysize(prog_80_10ffff)] = { 0 }; // does not need to be initialized; silences gcc warning
   for (int i = 0; i < arraysize(prog_80_10ffff); i++) {
     const ByteRangeProg& p = prog_80_10ffff[i];
     int next = 0;
     if (p.next >= 0)
       next = inst[p.next];
     inst[i] = UncachedRuneByteSuffix(p.lo, p.hi, false, next);
     if ((p.lo & 0xC0) != 0x80)
       AddSuffix(inst[i]);
   }
 }
@@ skipping 74 matching lines @@
   failed_ = true;
   return NoMatch();
 }
 
 // Called before traversing a node's children during the walk.
 Frag Compiler::PreVisit(Regexp* re, Frag, bool* stop) {
   // Cut off walk if we've already failed.
   if (failed_)
     *stop = true;
 
-  return kNullFrag;  // not used by caller
+  return NullFrag();  // not used by caller
 }
 
 Frag Compiler::Literal(Rune r, bool foldcase) {
   switch (encoding_) {
     default:
-      return kNullFrag;
+      return NullFrag();
 
     case kEncodingLatin1:
       return ByteRange(r, r, foldcase);
 
     case kEncodingUTF8: {
       if (r < Runeself)  // Make common case fast.
         return ByteRange(r, r, foldcase);
       uint8 buf[UTFmax];
       int n = runetochar(reinterpret_cast<char*>(buf), &r);
       Frag f = ByteRange((uint8)buf[0], buf[0], false);
@@ skipping 22 matching lines @@
     case kRegexpNoMatch:
       return NoMatch();
 
     case kRegexpEmptyMatch:
       return Nop();
 
     case kRegexpHaveMatch: {
       Frag f = Match(re->match_id());
       // Remember unanchored match to end of string.
       if (anchor_ != RE2::ANCHOR_BOTH)
-        f = Cat(DotStar(), f);
+        f = Cat(DotStar(), Cat(EmptyWidth(kEmptyEndText), f));
       return f;
     }
 
     case kRegexpConcat: {
       Frag f = child_frags[0];
       for (int i = 1; i < nchild_frags; i++)
         f = Cat(f, child_frags[i]);
       return f;
     }
 
@@ skipping 252 matching lines @@
   Regexp* sre = re->Simplify();
   if (sre == NULL)
     return NULL;
 
   // Record whether prog is anchored, removing the anchors.
   // (They get in the way of other optimizations.)
   bool is_anchor_start = IsAnchorStart(&sre, 0);
   bool is_anchor_end = IsAnchorEnd(&sre, 0);
 
   // Generate fragment for entire regexp.
-  Frag f = c.WalkExponential(sre, kNullFrag, 2*c.max_inst_);
+  Frag f = c.WalkExponential(sre, NullFrag(), 2*c.max_inst_);
   sre->Decref();
   if (c.failed_)
     return NULL;
 
   // Success!  Finish by putting Match node at end, and record start.
   // Turn off c.reversed_ (if it is set) to force the remaining concatenations
   // to behave normally.
   c.reversed_ = false;
   Frag all = c.Cat(f, c.Match(0));
   c.prog_->set_start(all.begin);
@@ skipping 70 matching lines @@
 
 // Compiles RE set to Prog.
 Prog* Compiler::CompileSet(const RE2::Options& options, RE2::Anchor anchor,
                            Regexp* re) {
   Compiler c;
 
   Regexp::ParseFlags pf = static_cast<Regexp::ParseFlags>(options.ParseFlags());
   c.Setup(pf, options.max_mem(), anchor);
 
   // Compile alternation of fragments.
-  Frag all = c.WalkExponential(re, kNullFrag, 2*c.max_inst_);
+  Frag all = c.WalkExponential(re, NullFrag(), 2*c.max_inst_);
   re->Decref();
   if (c.failed_)
     return NULL;
 
   if (anchor == RE2::UNANCHORED) {
     // The trailing .* was added while handling kRegexpHaveMatch.
     // We just have to add the leading one.
     all = c.Cat(c.DotStar(), all);
   }
 
@@ skipping 19 matching lines @@
 
   return prog;
 }
 
 Prog* Prog::CompileSet(const RE2::Options& options, RE2::Anchor anchor,
                        Regexp* re) {
   return Compiler::CompileSet(options, anchor, re);
 }
 
 }  // namespace re2