Update re2

third_party/re2/re2/prefilter.cc

 // Copyright 2009 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.
 
 #include "util/util.h"
 #include "re2/prefilter.h"
 #include "re2/re2.h"
 #include "re2/unicode_casefold.h"
 #include "re2/walker-inl.h"
 
 namespace re2 {
 
 static const int Trace = false;
 
 typedef set<string>::iterator SSIter;
 typedef set<string>::const_iterator ConstSSIter;
 
+GLOBAL_MUTEX(alloc_id_mutex);
 static int alloc_id = 100000;  // Used for debugging.
 // Initializes a Prefilter, allocating subs_ as necessary.
 Prefilter::Prefilter(Op op) {
   op_ = op;
   subs_ = NULL;
   if (op_ == AND || op_ == OR)
     subs_ = new vector<Prefilter*>;
 
+  GLOBAL_MUTEX_LOCK(alloc_id_mutex);
   alloc_id_ = alloc_id++;
+  GLOBAL_MUTEX_UNLOCK(alloc_id_mutex);
   VLOG(10) << "alloc_id: " << alloc_id_;
 }
 
 // Destroys a Prefilter.
 Prefilter::~Prefilter() {
   VLOG(10) << "Deleted: " << alloc_id_;
   if (subs_) {
-    for (int i = 0; i < subs_->size(); i++)
+    for (size_t i = 0; i < subs_->size(); i++)
       delete (*subs_)[i];
     delete subs_;
     subs_ = NULL;
   }
 }
 
 // Simplify if the node is an empty Or or And.
 Prefilter* Prefilter::Simplify() {
   if (op_ != AND && op_ != OR) {
     return this;
@@ skipping 48 matching lines @@
       delete a;
       return b;
     } else {
       delete b;
       return a;
     }
   }
 
   // If a and b match op, merge their contents.
   if (a->op() == op && b->op() == op) {
-    for (int i = 0; i < b->subs()->size(); i++) {
+    for (size_t i = 0; i < b->subs()->size(); i++) {
       Prefilter* bb = (*b->subs())[i];
       a->subs()->push_back(bb);
     }
     b->subs()->clear();
     delete b;
     return a;
   }
 
   // If a already has the same op as the op that is under construction
   // add in b (similarly if b already has the same op, add in a).
@@ skipping 54 matching lines @@
   return or_prefilter;
 }
 
 static Rune ToLowerRune(Rune r) {
   if (r < Runeself) {
     if ('A' <= r && r <= 'Z')
       r += 'a' - 'A';
     return r;
   }
 
-  CaseFold *f = LookupCaseFold(unicode_tolower, num_unicode_tolower, r);
+  const CaseFold *f = LookupCaseFold(unicode_tolower, num_unicode_tolower, r);
   if (f == NULL || r < f->lo)
     return r;
   return ApplyFold(f, r);
 }
 
 static Rune ToLowerRuneLatin1(Rune r) {
   if ('A' <= r && r <= 'Z')
     r += 'a' - 'A';
   return r;
 }
@@ skipping 296 matching lines @@
       Info* pre_arg,
       Info** child_args, int nchild_args);
 
   virtual Info* ShortVisit(
       Regexp* re,
       Info* parent_arg);
 
   bool latin1() { return latin1_; }
  private:
   bool latin1_;
-  DISALLOW_EVIL_CONSTRUCTORS(Walker);
+  DISALLOW_COPY_AND_ASSIGN(Walker);
 };
 
 Prefilter::Info* Prefilter::BuildInfo(Regexp* re) {
   if (Trace) {
     LOG(INFO) << "BuildPrefilter::Info: " << re->ToString();
   }
 
-  bool latin1 = re->parse_flags() & Regexp::Latin1;
+  bool latin1 = (re->parse_flags() & Regexp::Latin1) != 0;
   Prefilter::Info::Walker w(latin1);
   Prefilter::Info* info = w.WalkExponential(re, NULL, 100000);
 
   if (w.stopped_early()) {
     delete info;
     return NULL;
   }
 
   return info;
 }
@@ skipping 148 matching lines @@
       LOG(DFATAL) << "Bad op in Prefilter::DebugString: " << op_;
       return StringPrintf("op%d", op_);
     case NONE:
       return "*no-matches*";
     case ATOM:
       return atom_;
     case ALL:
       return "";
     case AND: {
       string s = "";
-      for (int i = 0; i < subs_->size(); i++) {
+      for (size_t i = 0; i < subs_->size(); i++) {
         if (i > 0)
           s += " ";
         Prefilter* sub = (*subs_)[i];
         s += sub ? sub->DebugString() : "<nil>";
       }
       return s;
     }
     case OR: {
       string s = "(";
-      for (int i = 0; i < subs_->size(); i++) {
+      for (size_t i = 0; i < subs_->size(); i++) {
         if (i > 0)
           s += "|";
         Prefilter* sub = (*subs_)[i];
         s += sub ? sub->DebugString() : "<nil>";
       }
       s += ")";
       return s;
     }
   }
 }
 
 Prefilter* Prefilter::FromRE2(const RE2* re2) {
   if (re2 == NULL)
     return NULL;
 
   Regexp* regexp = re2->Regexp();
   if (regexp == NULL)
     return NULL;
 
   return FromRegexp(regexp);
 }
 
 
 }  // namespace re2