Update re2

third_party/re2/util/pcre.cc

 // Copyright 2003-2009 Google Inc.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // This is a variant of PCRE's pcrecpp.cc, originally written at Google.
 // The main changes are the addition of the HitLimit method and
 // compilation as PCRE in namespace re2.
 
 #include <errno.h>
+#include <limits>
 #include "util/util.h"
 #include "util/flags.h"
 #include "util/pcre.h"
 
-#ifdef WIN32
-#define strtoll _strtoi64
-#define strtoull _strtoui64
-#endif
-
 #define PCREPORT(level) LOG(level)
 
 // Default PCRE limits.
 // Defaults chosen to allow a plausible amount of CPU and
 // not exceed main thread stacks.  Note that other threads
 // often have smaller stacks, and therefore tightening
 // regexp_stack_limit may frequently be necessary.
 DEFINE_int32(regexp_stack_limit, 256<<10, "default PCRE stack limit (bytes)");
 DEFINE_int32(regexp_match_limit, 1000000,
              "default PCRE match limit (function calls)");
 
+#ifndef USEPCRE
+
+// Fake just enough of the PCRE API to allow this file to build. :)
+
+struct pcre_extra {
+  int flags;
+  int match_limit;
+  int match_limit_recursion;
+};
+
+#define PCRE_EXTRA_MATCH_LIMIT 0
+#define PCRE_EXTRA_MATCH_LIMIT_RECURSION 0
+#define PCRE_ANCHORED 0
+#define PCRE_NOTEMPTY 0
+#define PCRE_ERROR_NOMATCH 1
+#define PCRE_ERROR_MATCHLIMIT 2
+#define PCRE_ERROR_RECURSIONLIMIT 3
+#define PCRE_INFO_CAPTURECOUNT 0
+
+void pcre_free(void*) {
+}
+
+pcre* pcre_compile(const char*, int, const char**, int*, const unsigned char*) {
+  return NULL;
+}
+
+int pcre_exec(const pcre*, const pcre_extra*, const char*, int, int, int, int*, int) {
+  return 0;
+}
+
+int pcre_fullinfo(const pcre*, const pcre_extra*, int, void*) {
+  return 0;
+}
+
+#endif
+
 namespace re2 {
 
 // Maximum number of args we can set
 static const int kMaxArgs = 16;
 static const int kVecSize = (1 + kMaxArgs) * 3;  // results + PCRE workspace
 
 // Approximate size of a recursive invocation of PCRE's
 // internal "match()" frame.  This varies depending on the
 // compiler and architecture, of course, so the constant is
 // just a conservative estimate.  To find the exact number,
@@ skipping 71 matching lines @@
   // beginning of a string.
   //
   // There are three types of anchoring we want:
   //    UNANCHORED      Compile the original pattern, and use
   //                    a pcre unanchored match.
   //    ANCHOR_START    Compile the original pattern, and use
   //                    a pcre anchored match.
   //    ANCHOR_BOTH     Tack a "\z" to the end of the original pattern
   //                    and use a pcre anchored match.
 
-  const char* error;
+  const char* error = "";
   int eoffset;
   pcre* re;
   if (anchor != ANCHOR_BOTH) {
     re = pcre_compile(pattern_.c_str(),
                       (options_ & EnabledCompileOptions),
                       &error, &eoffset, NULL);
   } else {
     // Tack a '\z' at the end of PCRE.  Parenthesize it first so that
     // the '\z' applies to all top-level alternatives in the regexp.
     string wrapped = "(?:";  // A non-counting grouping operator
@@ skipping 44 matching lines @@
   if (&a9 == &no_more_args)  goto done; args[n++] = &a9;
   if (&a10 == &no_more_args) goto done; args[n++] = &a10;
   if (&a11 == &no_more_args) goto done; args[n++] = &a11;
   if (&a12 == &no_more_args) goto done; args[n++] = &a12;
   if (&a13 == &no_more_args) goto done; args[n++] = &a13;
   if (&a14 == &no_more_args) goto done; args[n++] = &a14;
   if (&a15 == &no_more_args) goto done; args[n++] = &a15;
 done:
 
   int consumed;
-  int vec[kVecSize];
+  int vec[kVecSize] = {};
   return re.DoMatchImpl(text, ANCHOR_BOTH, &consumed, args, n, vec, kVecSize);
 }
 
 bool PCRE::PartialMatchFunctor::operator ()(const StringPiece& text,
                                           const PCRE& re,
                                           const Arg& a0,
                                           const Arg& a1,
                                           const Arg& a2,
                                           const Arg& a3,
                                           const Arg& a4,
@@ skipping 22 matching lines @@
   if (&a9 == &no_more_args)  goto done; args[n++] = &a9;
   if (&a10 == &no_more_args) goto done; args[n++] = &a10;
   if (&a11 == &no_more_args) goto done; args[n++] = &a11;
   if (&a12 == &no_more_args) goto done; args[n++] = &a12;
   if (&a13 == &no_more_args) goto done; args[n++] = &a13;
   if (&a14 == &no_more_args) goto done; args[n++] = &a14;
   if (&a15 == &no_more_args) goto done; args[n++] = &a15;
 done:
 
   int consumed;
-  int vec[kVecSize];
+  int vec[kVecSize] = {};
   return re.DoMatchImpl(text, UNANCHORED, &consumed, args, n, vec, kVecSize);
 }
 
 bool PCRE::ConsumeFunctor::operator ()(StringPiece* input,
                                      const PCRE& pattern,
                                      const Arg& a0,
                                      const Arg& a1,
                                      const Arg& a2,
                                      const Arg& a3,
                                      const Arg& a4,
@@ skipping 22 matching lines @@
   if (&a9 == &no_more_args)  goto done; args[n++] = &a9;
   if (&a10 == &no_more_args) goto done; args[n++] = &a10;
   if (&a11 == &no_more_args) goto done; args[n++] = &a11;
   if (&a12 == &no_more_args) goto done; args[n++] = &a12;
   if (&a13 == &no_more_args) goto done; args[n++] = &a13;
   if (&a14 == &no_more_args) goto done; args[n++] = &a14;
   if (&a15 == &no_more_args) goto done; args[n++] = &a15;
 done:
 
   int consumed;
-  int vec[kVecSize];
+  int vec[kVecSize] = {};
   if (pattern.DoMatchImpl(*input, ANCHOR_START, &consumed,
                           args, n, vec, kVecSize)) {
     input->remove_prefix(consumed);
     return true;
   } else {
     return false;
   }
 }
 
 bool PCRE::FindAndConsumeFunctor::operator ()(StringPiece* input,
@@ skipping 28 matching lines @@
   if (&a9 == &no_more_args)  goto done; args[n++] = &a9;
   if (&a10 == &no_more_args) goto done; args[n++] = &a10;
   if (&a11 == &no_more_args) goto done; args[n++] = &a11;
   if (&a12 == &no_more_args) goto done; args[n++] = &a12;
   if (&a13 == &no_more_args) goto done; args[n++] = &a13;
   if (&a14 == &no_more_args) goto done; args[n++] = &a14;
   if (&a15 == &no_more_args) goto done; args[n++] = &a15;
 done:
 
   int consumed;
-  int vec[kVecSize];
+  int vec[kVecSize] = {};
   if (pattern.DoMatchImpl(*input, UNANCHORED, &consumed,
                           args, n, vec, kVecSize)) {
     input->remove_prefix(consumed);
     return true;
   } else {
     return false;
   }
 }
 
 bool PCRE::Replace(string *str,
                  const PCRE& pattern,
                  const StringPiece& rewrite) {
-  int vec[kVecSize];
+  int vec[kVecSize] = {};
   int matches = pattern.TryMatch(*str, 0, UNANCHORED, true, vec, kVecSize);
   if (matches == 0)
     return false;
 
   string s;
   if (!pattern.Rewrite(&s, rewrite, *str, vec, matches))
     return false;
 
   assert(vec[0] >= 0);
   assert(vec[1] >= 0);
   str->replace(vec[0], vec[1] - vec[0], s);
   return true;
 }
 
 int PCRE::GlobalReplace(string *str,
                       const PCRE& pattern,
                       const StringPiece& rewrite) {
   int count = 0;
-  int vec[kVecSize];
+  int vec[kVecSize] = {};
   string out;
   int start = 0;
   bool last_match_was_empty_string = false;
 
-  for (; start <= str->length();) {
+  while (start <= static_cast<int>(str->size())) {
     // If the previous match was for the empty string, we shouldn't
     // just match again: we'll match in the same way and get an
     // infinite loop.  Instead, we do the match in a special way:
     // anchored -- to force another try at the same position --
     // and with a flag saying that this time, ignore empty matches.
     // If this special match returns, that means there's a non-empty
     // match at this position as well, and we can continue.  If not,
     // we do what perl does, and just advance by one.
     // Notice that perl prints '@@@' for this;
     //    perl -le '$_ = "aa"; s/b*|aa/@/g; print'
     int matches;
     if (last_match_was_empty_string) {
       matches = pattern.TryMatch(*str, start, ANCHOR_START, false,
                                  vec, kVecSize);
       if (matches <= 0) {
-        if (start < str->length())
+        if (start < static_cast<int>(str->size()))
           out.push_back((*str)[start]);
         start++;
         last_match_was_empty_string = false;
         continue;
       }
     } else {
-      matches = pattern.TryMatch(*str, start, UNANCHORED, true, vec, kVecSize);
+      matches = pattern.TryMatch(*str, start, UNANCHORED, true,
+                                 vec, kVecSize);
       if (matches <= 0)
         break;
     }
     int matchstart = vec[0], matchend = vec[1];
     assert(matchstart >= start);
     assert(matchend >= matchstart);
 
     out.append(*str, start, matchstart - start);
     pattern.Rewrite(&out, rewrite, *str, vec, matches);
     start = matchend;
     count++;
     last_match_was_empty_string = (matchstart == matchend);
   }
 
   if (count == 0)
     return 0;
 
-  if (start < str->length())
-    out.append(*str, start, str->length() - start);
+  if (start < static_cast<int>(str->size()))
+    out.append(*str, start, static_cast<int>(str->size()) - start);
   swap(out, *str);
   return count;
 }
 
 bool PCRE::Extract(const StringPiece &text,
                  const PCRE& pattern,
                  const StringPiece &rewrite,
                  string *out) {
-  int vec[kVecSize];
+  int vec[kVecSize] = {};
   int matches = pattern.TryMatch(text, 0, UNANCHORED, true, vec, kVecSize);
   if (matches == 0)
     return false;
   out->clear();
   return pattern.Rewrite(out, rewrite, text, vec, matches);
 }
 
 string PCRE::QuoteMeta(const StringPiece& unquoted) {
   string result;
   result.reserve(unquoted.size() << 1);
@@ skipping 25 matching lines @@
     }
     result += unquoted[ii];
   }
 
   return result;
 }
 
 /***** Actual matching and rewriting code *****/
 
 bool PCRE::HitLimit() {
-  return hit_limit_;
+  return hit_limit_ != 0;
 }
 
 void PCRE::ClearHitLimit() {
   hit_limit_ = 0;
 }
 
 int PCRE::TryMatch(const StringPiece& text,
                  int startpos,
                  Anchor anchor,
                  bool empty_ok,
@@ skipping 127 matching lines @@
 
   return true;
 }
 
 bool PCRE::DoMatch(const StringPiece& text,
                  Anchor anchor,
                  int* consumed,
                  const Arg* const args[],
                  int n) const {
   assert(n >= 0);
-  size_t const vecsize = (1 + n) * 3;  // results + PCRE workspace
-                                       // (as for kVecSize)
-  int *vec = new int[vecsize];
+  const int vecsize = (1 + n) * 3;  // results + PCRE workspace
+                                    // (as for kVecSize)
+  int* vec = new int[vecsize];
   bool b = DoMatchImpl(text, anchor, consumed, args, n, vec, vecsize);
   delete[] vec;
   return b;
 }
 
 bool PCRE::Rewrite(string *out, const StringPiece &rewrite,
                  const StringPiece &text, int *vec, int veclen) const {
   int number_of_capturing_groups = NumberOfCapturingGroups();
   for (const char *s = rewrite.data(), *end = s + rewrite.size();
        s < end; s++) {
@@ skipping 185 matching lines @@
 }
 
 bool PCRE::Arg::parse_short_radix(const char* str,
                                 int n,
                                 void* dest,
                                 int radix) {
   long r;
   if (!parse_long_radix(str, n, &r, radix)) return false; // Could not parse
   if ((short)r != r) return false;       // Out of range
   if (dest == NULL) return true;
-  *(reinterpret_cast<short*>(dest)) = r;
+  *(reinterpret_cast<short*>(dest)) = (short)r;
   return true;
 }
 
 bool PCRE::Arg::parse_ushort_radix(const char* str,
                                  int n,
                                  void* dest,
                                  int radix) {
   unsigned long r;
   if (!parse_ulong_radix(str, n, &r, radix)) return false; // Could not parse
   if ((ushort)r != r) return false;                      // Out of range
   if (dest == NULL) return true;
-  *(reinterpret_cast<unsigned short*>(dest)) = r;
+  *(reinterpret_cast<unsigned short*>(dest)) = (ushort)r;
   return true;
 }
 
 bool PCRE::Arg::parse_int_radix(const char* str,
                               int n,
                               void* dest,
                               int radix) {
   long r;
   if (!parse_long_radix(str, n, &r, radix)) return false; // Could not parse
   if ((int)r != r) return false;         // Out of range
@@ skipping 57 matching lines @@
   if (n == 0) return false;
   static const int kMaxLength = 200;
   char buf[kMaxLength];
   if (n >= kMaxLength) return false;
   memcpy(buf, str, n);
   buf[n] = '\0';
   errno = 0;
   char* end;
   double r = strtod(buf, &end);
   if (end != buf + n) {
-#ifdef COMPILER_MSVC
+#ifdef _WIN32
     // Microsoft's strtod() doesn't handle inf and nan, so we have to
     // handle it explicitly.  Speed is not important here because this
     // code is only called in unit tests.
     bool pos = true;
     const char* i = buf;
     if ('-' == *i) {
       pos = false;
       ++i;
     } else if ('+' == *i) {
       ++i;
     }
     if (0 == stricmp(i, "inf") || 0 == stricmp(i, "infinity")) {
-      r = numeric_limits<double>::infinity();
+      r = std::numeric_limits<double>::infinity();
       if (!pos)
         r = -r;
     } else if (0 == stricmp(i, "nan")) {
-      r = numeric_limits<double>::quiet_NaN();
+      r = std::numeric_limits<double>::quiet_NaN();
     } else {
       return false;
     }
 #else
     return false;   // Leftover junk
 #endif
   }
   if (errno) return false;
   if (dest == NULL) return true;
   *(reinterpret_cast<double*>(dest)) = r;
@@ skipping 28 matching lines @@
 DEFINE_INTEGER_PARSERS(int);
 DEFINE_INTEGER_PARSERS(uint);
 DEFINE_INTEGER_PARSERS(long);
 DEFINE_INTEGER_PARSERS(ulong);
 DEFINE_INTEGER_PARSERS(longlong);
 DEFINE_INTEGER_PARSERS(ulonglong);
 
 #undef DEFINE_INTEGER_PARSERS
 
 }  // namespace re2