Revert of Update re2

third_party/re2/util/pcre.h

 // Copyright 2003-2010 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.h, originally written at Google.
 // The main changes are the addition of the HitLimit method and
 // compilation as PCRE in namespace re2.
 
 // C++ interface to the pcre regular-expression library.  PCRE supports
 // Perl-style regular expressions (with extensions like \d, \w, \s,
@@ skipping 149 matching lines @@
 
 #include "util/util.h"
 #include "re2/stringpiece.h"
 
 #ifdef USEPCRE
 #include <pcre.h>
 namespace re2 {
 const bool UsingPCRE = true;
 }  // namespace re2
 #else
-struct pcre;  // opaque
 namespace re2 {
 const bool UsingPCRE = false;
+struct pcre;
+struct pcre_extra { int flags, match_limit, match_limit_recursion; };
+#define pcre_free(x) {}
+#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
+#ifndef WIN32
+#define pcre_compile(a,b,c,d,e) ({ (void)(a); (void)(b); *(c)=""; *(d)=0; (void)(e); ((pcre*)0); })
+#define pcre_exec(a, b, c, d, e, f, g, h) ({ (void)(a); (void)(b); (void)(c); (void)(d); (void)(e); (void)(f); (void)(g); (void)(h); 0; })
+#define pcre_fullinfo(a, b, c, d) ({ (void)(a); (void)(b); (void)(c); *(d) = 0; 0; })
+#else
+#define pcre_compile(a,b,c,d,e) NULL
+#define pcre_exec(a, b, c, d, e, f, g, h) NULL
+#define pcre_fullinfo(a, b, c, d) NULL
+#endif
 }  // namespace re2
 #endif
 
 namespace re2 {
 
 class PCRE_Options;
 
 // Interface for regular expression matching.  Also corresponds to a
 // pre-compiled regular expression.  An "PCRE" object is safe for
 // concurrent use by multiple threads.
@@ skipping 307 matching lines @@
 
   string            pattern_;
   Option            options_;
   pcre*             re_full_;        // For full matches
   pcre*             re_partial_;     // For partial matches
   const string*     error_;          // Error indicator (or empty string)
   bool              report_errors_;  // Silences error logging if false
   int               match_limit_;    // Limit on execution resources
   int               stack_limit_;    // Limit on stack resources (bytes)
   mutable int32_t  hit_limit_;  // Hit limit during execution (bool)?
-  DISALLOW_COPY_AND_ASSIGN(PCRE);
+  DISALLOW_EVIL_CONSTRUCTORS(PCRE);
 };
 
 // PCRE_Options allow you to set the PCRE::Options, plus any pcre
 // "extra" options.  The only extras are match_limit, which limits
 // the CPU time of a match, and stack_limit, which limits the
 // stack usage.  Setting a limit to <= 0 lets PCRE pick a sensible default
 // that should not cause too many problems in production code.
 // If PCRE hits a limit during a match, it may return a false negative,
 // but (hopefully) it won't crash.
 //
@@ skipping 146 matching lines @@
 MAKE_INTEGER_PARSER(int,                int);
 MAKE_INTEGER_PARSER(unsigned int,       uint);
 MAKE_INTEGER_PARSER(long,               long);
 MAKE_INTEGER_PARSER(unsigned long,      ulong);
 MAKE_INTEGER_PARSER(long long,          longlong);
 MAKE_INTEGER_PARSER(unsigned long long, ulonglong);
 
 #undef MAKE_INTEGER_PARSER
 
 }  // namespace re2