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

third_party/re2/re2/regexp.cc

 // Copyright 2006 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 representation.
 // Tested by parse_test.cc
 
 #include "util/util.h"
 #include "re2/regexp.h"
 #include "re2/stringpiece.h"
@@ skipping 41 matching lines @@
 // If it's possible to destroy this regexp without recurring,
 // do so and return true.  Else return false.
 bool Regexp::QuickDestroy() {
   if (nsub_ == 0) {
     delete this;
     return true;
   }
   return false;
 }
 
-static map<Regexp*, int> ref_map;
-static Mutex ref_mutex;
+static map<Regexp*, int> *ref_map;
+GLOBAL_MUTEX(ref_mutex);
 
 int Regexp::Ref() {
   if (ref_ < kMaxRef)
     return ref_;
 
-  MutexLock l(&ref_mutex);
-  return ref_map[this];
+  GLOBAL_MUTEX_LOCK(ref_mutex);
+  int r = 0;
+  if (ref_map != NULL) {
+    r = (*ref_map)[this];
+  }
+  GLOBAL_MUTEX_UNLOCK(ref_mutex);
+  return r;
 }
 
 // Increments reference count, returns object as convenience.
 Regexp* Regexp::Incref() {
   if (ref_ >= kMaxRef-1) {
     // Store ref count in overflow map.
-    MutexLock l(&ref_mutex);
-    if (ref_ == kMaxRef) {  // already overflowed
-      ref_map[this]++;
-      return this;
+    GLOBAL_MUTEX_LOCK(ref_mutex);
+    if (ref_map == NULL) {
+      ref_map = new map<Regexp*, int>;
     }
-    // overflowing now
-    ref_map[this] = kMaxRef;
-    ref_ = kMaxRef;
+    if (ref_ == kMaxRef) {
+      // already overflowed
+      (*ref_map)[this]++;
+    } else {
+      // overflowing now
+      (*ref_map)[this] = kMaxRef;
+      ref_ = kMaxRef;
+    }
+    GLOBAL_MUTEX_UNLOCK(ref_mutex);
     return this;
   }
 
   ref_++;
   return this;
 }
 
 // Decrements reference count and deletes this object if count reaches 0.
 void Regexp::Decref() {
   if (ref_ == kMaxRef) {
     // Ref count is stored in overflow map.
-    MutexLock l(&ref_mutex);
-    int r = ref_map[this] - 1;
+    GLOBAL_MUTEX_LOCK(ref_mutex);
+    int r = (*ref_map)[this] - 1;
     if (r < kMaxRef) {
       ref_ = r;
-      ref_map.erase(this);
+      ref_map->erase(this);
     } else {
-      ref_map[this] = r;
+      (*ref_map)[this] = r;
     }
+    GLOBAL_MUTEX_UNLOCK(ref_mutex);
     return;
   }
   ref_--;
   if (ref_ == 0)
     Destroy();
 }
 
 // Deletes this object; ref count has count reached 0.
 void Regexp::Destroy() {
   if (QuickDestroy())
@@ skipping 326 matching lines @@
 
     a = stk[n-2];
     b = stk[n-1];
     stk.resize(n-2);
   }
 
   return true;
 }
 
 // Keep in sync with enum RegexpStatusCode in regexp.h
-static const string kErrorStrings[] = {
+static const char *kErrorStrings[] = {
   "no error",
   "unexpected error",
   "invalid escape sequence",
   "invalid character class",
   "invalid character class range",
   "missing ]",
   "missing )",
   "trailing \\",
   "no argument for repetition operator",
   "invalid repetition size",
   "bad repetition operator",
   "invalid perl operator",
   "invalid UTF-8",
   "invalid named capture group",
 };
 
-const string& RegexpStatus::CodeText(enum RegexpStatusCode code) {
+string RegexpStatus::CodeText(enum RegexpStatusCode code) {
   if (code < 0 || code >= arraysize(kErrorStrings))
     code = kRegexpInternalError;
   return kErrorStrings[code];
 }
 
 string RegexpStatus::Text() const {
   if (error_arg_.empty())
     return CodeText(code_);
   string s;
   s.append(CodeText(code_));
@@ skipping 433 matching lines @@
   for (iterator it = begin(); it != end(); ++it)
     cc->ranges_[n++] = *it;
   cc->nranges_ = n;
   DCHECK_LE(n, ranges_.size());
   cc->nrunes_ = nrunes_;
   cc->folds_ascii_ = FoldsASCII();
   return cc;
 }
 
 }  // namespace re2