Update re2

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 212 matching lines @@
   int inst_len_;       // Number of instructions used.
   int inst_cap_;       // Number of instructions allocated.
 
   int64 max_mem_;      // Total memory budget.
 
   map<uint64, int> rune_cache_;
   Frag rune_range_;
 
   RE2::Anchor anchor_;  // anchor mode for RE2::Set
 
-  DISALLOW_EVIL_CONSTRUCTORS(Compiler);
+  DISALLOW_COPY_AND_ASSIGN(Compiler);
 };
 
 Compiler::Compiler() {
   prog_ = new Prog();
   failed_ = false;
   encoding_ = kEncodingUTF8;
   reversed_ = false;
   inst_ = NULL;
   inst_len_ = 0;
   inst_cap_ = 0;
@@ skipping 120 matching lines @@
 
 // Given a fragment for a, returns a fragment for a+ or a+? (if nongreedy)
 Frag Compiler::Plus(Frag a, bool nongreedy) {
   // a+ is just a* with a different entry point.
   Frag f = Star(a, nongreedy);
   return Frag(a.begin, f.end);
 }
 
 // Given a fragment for a, returns a fragment for a? or a?? (if nongreedy)
 Frag Compiler::Quest(Frag a, bool nongreedy) {
+  if (IsNoMatch(a))
+    return Nop();
   int id = AllocInst(1);
   if (id < 0)
     return NoMatch();
   PatchList pl;
   if (nongreedy) {
     inst_[id].InitAlt(0, a.begin);
     pl = PatchList::Mk(id << 1);
   } else {
     inst_[id].InitAlt(a.begin, 0);
     pl = PatchList::Mk((id << 1) | 1);
@@ skipping 42 matching lines @@
 Frag Compiler::EmptyWidth(EmptyOp empty) {
   int id = AllocInst(1);
   if (id < 0)
     return NoMatch();
   inst_[id].InitEmptyWidth(empty, 0);
   if (empty & (kEmptyBeginLine|kEmptyEndLine))
     prog_->MarkByteRange('\n', '\n');
   if (empty & (kEmptyWordBoundary|kEmptyNonWordBoundary)) {
     int j;
     for (int i = 0; i < 256; i = j) {
-      for (j = i+1; j < 256 && Prog::IsWordChar(i) == Prog::IsWordChar(j); j++)
+      for (j = i + 1; j < 256 &&
+                      Prog::IsWordChar(static_cast<uint8>(i)) ==
+                          Prog::IsWordChar(static_cast<uint8>(j));
+           j++)
         ;
       prog_->MarkByteRange(i, j-1);
     }
   }
   return Frag(id, PatchList::Mk(id << 1));
 }
 
 // Given a fragment a, returns a fragment with capturing parens around a.
 Frag Compiler::Capture(Frag a, int n) {
+  if (IsNoMatch(a))
+    return NoMatch();
   int id = AllocInst(2);
   if (id < 0)
     return NoMatch();
   inst_[id].InitCapture(2*n, a.begin);
   inst_[id+1].InitCapture(2*n+1, 0);
   PatchList::Patch(inst_, a.end, id+1);
 
   return Frag(id, PatchList::Mk((id+1) << 1));
 }
 
@@ skipping 36 matching lines @@
 int Compiler::RuneByteSuffix(uint8 lo, uint8 hi, bool foldcase, int next) {
   // In Latin1 mode, there's no point in caching.
   // In forward UTF-8 mode, only need to cache continuation bytes.
   if (encoding_ == kEncodingLatin1 ||
       (encoding_ == kEncodingUTF8 &&
        !reversed_ &&
        !(0x80 <= lo && hi <= 0xbf))) {
     return UncachedRuneByteSuffix(lo, hi, foldcase, next);
   }
 
-  uint64 key = ((uint64)next << 17) | (lo<<9) | (hi<<1) | (foldcase ? 1ULL : 0ULL);
+  uint64 key = (uint64)next << 17 |
+               (uint64)lo   <<  9 |
+               (uint64)hi   <<  1 |
+               (uint64)foldcase;
   map<uint64, int>::iterator it = rune_cache_.find(key);
   if (it != rune_cache_.end())
     return it->second;
   int id = UncachedRuneByteSuffix(lo, hi, foldcase, next);
   rune_cache_[key] = id;
   return id;
 }
 
 void Compiler::AddSuffix(int id) {
   if (rune_range_.begin == 0) {
@@ skipping 31 matching lines @@
       break;
   }
 }
 
 void Compiler::AddRuneRangeLatin1(Rune lo, Rune hi, bool foldcase) {
   // Latin1 is easy: runes *are* bytes.
   if (lo > hi || lo > 0xFF)
     return;
   if (hi > 0xFF)
     hi = 0xFF;
-  AddSuffix(RuneByteSuffix(lo, hi, foldcase, 0));
+  AddSuffix(RuneByteSuffix(static_cast<uint8>(lo), static_cast<uint8>(hi),
+                           foldcase, 0));
 }
 
 // Table describing how to make a UTF-8 matching machine
 // for the rune range 80-10FFFF (Runeself-Runemax).
 // This range happens frequently enough (for example /./ and /[^a-z]/)
 // and the rune_cache_ map is slow enough that this is worth
 // special handling.  Makes compilation of a small expression
 // with a dot in it about 10% faster.
 // The * in the comments below mark whole sequences.
 static struct ByteRangeProg {
@@ skipping 20 matching lines @@
   { 10, 0xF4, 0xF4, },  // 11: F4 80-8F 80-BF 80-BF*
 };
 
 void Compiler::Add_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);
+    inst[i] = UncachedRuneByteSuffix(static_cast<uint8>(p.lo),
+                                     static_cast<uint8>(p.hi), false, next);
     if ((p.lo & 0xC0) != 0x80)
       AddSuffix(inst[i]);
   }
 }
 
 void Compiler::AddRuneRangeUTF8(Rune lo, Rune hi, bool foldcase) {
   if (lo > hi)
     return;
 
   // Pick off 80-10FFFF as a common special case
   // that can bypass the slow rune_cache_.
   if (lo == 0x80 && hi == 0x10ffff && !reversed_) {
     Add_80_10ffff();
     return;
   }
 
   // Split range into same-length sized ranges.
   for (int i = 1; i < UTFmax; i++) {
     Rune max = MaxRune(i);
     if (lo <= max && max < hi) {
       AddRuneRangeUTF8(lo, max, foldcase);
       AddRuneRangeUTF8(max+1, hi, foldcase);
       return;
     }
   }
 
   // ASCII range is always a special case.
   if (hi < Runeself) {
-    AddSuffix(RuneByteSuffix(lo, hi, foldcase, 0));
+    AddSuffix(RuneByteSuffix(static_cast<uint8>(lo), static_cast<uint8>(hi),
+                             foldcase, 0));
     return;
   }
 
   // Split range into sections that agree on leading bytes.
   for (int i = 1; i < UTFmax; i++) {
     uint m = (1<<(6*i)) - 1;  // last i bytes of a UTF-8 sequence
     if ((lo & ~m) != (hi & ~m)) {
       if ((lo & m) != 0) {
         AddRuneRangeUTF8(lo, lo|m, foldcase);
         AddRuneRangeUTF8((lo|m)+1, hi, foldcase);
@@ skipping 107 matching lines @@
     }
 
     case kRegexpAlternate: {
       Frag f = child_frags[0];
       for (int i = 1; i < nchild_frags; i++)
         f = Alt(f, child_frags[i]);
       return f;
     }
 
     case kRegexpStar:
-      return Star(child_frags[0], re->parse_flags()&Regexp::NonGreedy);
+      return Star(child_frags[0], (re->parse_flags()&Regexp::NonGreedy) != 0);
 
     case kRegexpPlus:
-      return Plus(child_frags[0], re->parse_flags()&Regexp::NonGreedy);
+      return Plus(child_frags[0], (re->parse_flags()&Regexp::NonGreedy) != 0);
 
     case kRegexpQuest:
-      return Quest(child_frags[0], re->parse_flags()&Regexp::NonGreedy);
+      return Quest(child_frags[0], (re->parse_flags()&Regexp::NonGreedy) != 0);
 
     case kRegexpLiteral:
-      return Literal(re->rune(), re->parse_flags()&Regexp::FoldCase);
+      return Literal(re->rune(), (re->parse_flags()&Regexp::FoldCase) != 0);
 
     case kRegexpLiteralString: {
       // Concatenation of literals.
       if (re->nrunes() == 0)
         return Nop();
       Frag f;
       for (int i = 0; i < re->nrunes(); i++) {
-        Frag f1 = Literal(re->runes()[i], re->parse_flags()&Regexp::FoldCase);
+        Frag f1 = Literal(re->runes()[i],
+                          (re->parse_flags()&Regexp::FoldCase) != 0);
         if (i == 0)
           f = f1;
         else
           f = Cat(f, f1);
       }
       return f;
     }
 
     case kRegexpAnyChar:
       BeginRange();
@@ skipping 24 matching lines @@
       // character ranges in the class.
       BeginRange();
       for (CharClass::iterator i = cc->begin(); i != cc->end(); ++i) {
         // ASCII case-folding optimization (see above).
         if (foldascii && 'A' <= i->lo && i->hi <= 'Z')
           continue;
 
         // If this range contains all of A-Za-z or none of it,
         // the fold flag is unnecessary; don't bother.
         bool fold = foldascii;
-        if ((i->lo <= 'A' && 'z' <= i->hi) || i->hi < 'A' || 'z' < i->lo)
+        if ((i->lo <= 'A' && 'z' <= i->hi) || i->hi < 'A' || 'z' < i->lo ||
+            ('Z' < i->lo && i->hi < 'a'))
           fold = false;
 
         AddRuneRange(i->lo, i->hi, fold);
       }
       return EndRange();
     }
 
     case kRegexpCapture:
       // If this is a non-capturing parenthesis -- (?:foo) --
       // just use the inner expression.
@@ skipping 122 matching lines @@
 
 void Compiler::Setup(Regexp::ParseFlags flags, int64 max_mem,
                      RE2::Anchor anchor) {
   prog_->set_flags(flags);
 
   if (flags & Regexp::Latin1)
     encoding_ = kEncodingLatin1;
   max_mem_ = max_mem;
   if (max_mem <= 0) {
     max_inst_ = 100000;  // more than enough
-  } else if (max_mem <= sizeof(Prog)) {
+  } else if (max_mem <= static_cast<int64>(sizeof(Prog))) {
     // No room for anything.
     max_inst_ = 0;
   } else {
     int64 m = (max_mem - sizeof(Prog)) / sizeof(Prog::Inst);
     // Limit instruction count so that inst->id() fits nicely in an int.
     // SparseArray also assumes that the indices (inst->id()) are ints.
     // The call to WalkExponential uses 2*max_inst_ below,
     // and other places in the code use 2 or 3 * prog->size().
     // Limiting to 2^24 should avoid overflow in those places.
     // (The point of allowing more than 32 bits of memory is to
     // have plenty of room for the DFA states, not to use it up
     // on the program.)
     if (m >= 1<<24)
       m = 1<<24;
 
     // Inst imposes its own limit (currently bigger than 2^24 but be safe).
     if (m > Prog::Inst::kMaxInst)
       m = Prog::Inst::kMaxInst;
 
-    max_inst_ = m;
+    max_inst_ = static_cast<int>(m);
   }
 
   anchor_ = anchor;
 }
 
 // Compiles re, returning program.
 // Caller is responsible for deleting prog_.
 // If reversed is true, compiles a program that expects
 // to run over the input string backward (reverses all concatenations).
 // The reversed flag is also recorded in the returned program.
@@ skipping 139 matching lines @@
 
   return prog;
 }
 
 Prog* Prog::CompileSet(const RE2::Options& options, RE2::Anchor anchor,
                        Regexp* re) {
   return Compiler::CompileSet(options, anchor, re);
 }
 
 }  // namespace re2