third_party/re2/patches/re2-msvc9-chrome.patch

diff --git a/AUTHORS b/AUTHORS
index 3c0f928..e17d9bf 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -8,5 +8,6 @@
 
 # Please keep the list sorted.
 
+Brian Gunlogson <unixman83@gmail.com>
 Google Inc.
 Stefano Rivera <stefano.rivera@gmail.com>
diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index 7b44e04..7f6a93d 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -26,6 +26,7 @@
 
 # Please keep the list sorted.
 
+Brian Gunlogson <unixman83@gmail.com>
 Dominic Battré <battre@chromium.org>
 John Millikin <jmillikin@gmail.com>
 Rob Pike <r@google.com>
diff --git a/mswin/stdint.h b/mswin/stdint.h
new file mode 100644
index 0000000..d02608a
--- /dev/null
+++ b/mswin/stdint.h
@@ -0,0 +1,247 @@
+// ISO C9x  compliant stdint.h for Microsoft Visual Studio
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 
+// 
+//  Copyright (c) 2006-2008 Alexander Chemeris
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+//   1. Redistributions of source code must retain the above copyright notice,
+//      this list of conditions and the following disclaimer.
+// 
+//   2. Redistributions in binary form must reproduce the above copyright
+//      notice, this list of conditions and the following disclaimer in the
+//      documentation and/or other materials provided with the distribution.
+// 
+//   3. The name of the author may be used to endorse or promote products
+//      derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _MSC_VER // [
+#error "Use this header only with Microsoft Visual C++ compilers!"
+#endif // _MSC_VER ]
+
+#ifndef _MSC_STDINT_H_ // [
+#define _MSC_STDINT_H_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#include <limits.h>
+
+// For Visual Studio 6 in C++ mode and for many Visual Studio versions when
+// compiling for ARM we should wrap <wchar.h> include with 'extern "C++" {}'
+// or compiler give many errors like this:
+//   error C2733: second C linkage of overloaded function 'wmemchr' not allowed
+#ifdef __cplusplus
+extern "C" {
+#endif
+#  include <wchar.h>
+#ifdef __cplusplus
+}
+#endif
+
+// Define _W64 macros to mark types changing their size, like intptr_t.
+#ifndef _W64
+#  if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
+#     define _W64 __w64
+#  else
+#     define _W64
+#  endif
+#endif
+
+
+// 7.18.1 Integer types
+
+// 7.18.1.1 Exact-width integer types
+
+// Visual Studio 6 and Embedded Visual C++ 4 doesn't
+// realize that, e.g. char has the same size as __int8
+// so we give up on __intX for them.
+#if (_MSC_VER < 1300)
+   typedef signed char       int8_t;
+   typedef signed short      int16_t;
+   typedef signed int        int32_t;
+   typedef unsigned char     uint8_t;
+   typedef unsigned short    uint16_t;
+   typedef unsigned int      uint32_t;
+#else
+   typedef signed __int8     int8_t;
+   typedef signed __int16    int16_t;
+   typedef signed __int32    int32_t;
+   typedef unsigned __int8   uint8_t;
+   typedef unsigned __int16  uint16_t;
+   typedef unsigned __int32  uint32_t;
+#endif
+typedef signed __int64       int64_t;
+typedef unsigned __int64     uint64_t;
+
+
+// 7.18.1.2 Minimum-width integer types
+typedef int8_t    int_least8_t;
+typedef int16_t   int_least16_t;
+typedef int32_t   int_least32_t;
+typedef int64_t   int_least64_t;
+typedef uint8_t   uint_least8_t;
+typedef uint16_t  uint_least16_t;
+typedef uint32_t  uint_least32_t;
+typedef uint64_t  uint_least64_t;
+
+// 7.18.1.3 Fastest minimum-width integer types
+typedef int8_t    int_fast8_t;
+typedef int16_t   int_fast16_t;
+typedef int32_t   int_fast32_t;
+typedef int64_t   int_fast64_t;
+typedef uint8_t   uint_fast8_t;
+typedef uint16_t  uint_fast16_t;
+typedef uint32_t  uint_fast32_t;
+typedef uint64_t  uint_fast64_t;
+
+// 7.18.1.4 Integer types capable of holding object pointers
+#ifdef _WIN64 // [
+   typedef signed __int64    intptr_t;
+   typedef unsigned __int64  uintptr_t;
+#else // _WIN64 ][
+   typedef _W64 signed int   intptr_t;
+   typedef _W64 unsigned int uintptr_t;
+#endif // _WIN64 ]
+
+// 7.18.1.5 Greatest-width integer types
+typedef int64_t   intmax_t;
+typedef uint64_t  uintmax_t;
+
+
+// 7.18.2 Limits of specified-width integer types
+
+#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [   See footnote 220 at page 257 and footnote 221 at page 259
+
+// 7.18.2.1 Limits of exact-width integer types
+#define INT8_MIN     ((int8_t)_I8_MIN)
+#define INT8_MAX     _I8_MAX
+#define INT16_MIN    ((int16_t)_I16_MIN)
+#define INT16_MAX    _I16_MAX
+#define INT32_MIN    ((int32_t)_I32_MIN)
+#define INT32_MAX    _I32_MAX
+#define INT64_MIN    ((int64_t)_I64_MIN)
+#define INT64_MAX    _I64_MAX
+#define UINT8_MAX    _UI8_MAX
+#define UINT16_MAX   _UI16_MAX
+#define UINT32_MAX   _UI32_MAX
+#define UINT64_MAX   _UI64_MAX
+
+// 7.18.2.2 Limits of minimum-width integer types
+#define INT_LEAST8_MIN    INT8_MIN
+#define INT_LEAST8_MAX    INT8_MAX
+#define INT_LEAST16_MIN   INT16_MIN
+#define INT_LEAST16_MAX   INT16_MAX
+#define INT_LEAST32_MIN   INT32_MIN
+#define INT_LEAST32_MAX   INT32_MAX
+#define INT_LEAST64_MIN   INT64_MIN
+#define INT_LEAST64_MAX   INT64_MAX
+#define UINT_LEAST8_MAX   UINT8_MAX
+#define UINT_LEAST16_MAX  UINT16_MAX
+#define UINT_LEAST32_MAX  UINT32_MAX
+#define UINT_LEAST64_MAX  UINT64_MAX
+
+// 7.18.2.3 Limits of fastest minimum-width integer types
+#define INT_FAST8_MIN    INT8_MIN
+#define INT_FAST8_MAX    INT8_MAX
+#define INT_FAST16_MIN   INT16_MIN
+#define INT_FAST16_MAX   INT16_MAX
+#define INT_FAST32_MIN   INT32_MIN
+#define INT_FAST32_MAX   INT32_MAX
+#define INT_FAST64_MIN   INT64_MIN
+#define INT_FAST64_MAX   INT64_MAX
+#define UINT_FAST8_MAX   UINT8_MAX
+#define UINT_FAST16_MAX  UINT16_MAX
+#define UINT_FAST32_MAX  UINT32_MAX
+#define UINT_FAST64_MAX  UINT64_MAX
+
+// 7.18.2.4 Limits of integer types capable of holding object pointers
+#ifdef _WIN64 // [
+#  define INTPTR_MIN   INT64_MIN
+#  define INTPTR_MAX   INT64_MAX
+#  define UINTPTR_MAX  UINT64_MAX
+#else // _WIN64 ][
+#  define INTPTR_MIN   INT32_MIN
+#  define INTPTR_MAX   INT32_MAX
+#  define UINTPTR_MAX  UINT32_MAX
+#endif // _WIN64 ]
+
+// 7.18.2.5 Limits of greatest-width integer types
+#define INTMAX_MIN   INT64_MIN
+#define INTMAX_MAX   INT64_MAX
+#define UINTMAX_MAX  UINT64_MAX
+
+// 7.18.3 Limits of other integer types
+
+#ifdef _WIN64 // [
+#  define PTRDIFF_MIN  _I64_MIN
+#  define PTRDIFF_MAX  _I64_MAX
+#else  // _WIN64 ][
+#  define PTRDIFF_MIN  _I32_MIN
+#  define PTRDIFF_MAX  _I32_MAX
+#endif  // _WIN64 ]
+
+#define SIG_ATOMIC_MIN  INT_MIN
+#define SIG_ATOMIC_MAX  INT_MAX
+
+#ifndef SIZE_MAX // [
+#  ifdef _WIN64 // [
+#     define SIZE_MAX  _UI64_MAX
+#  else // _WIN64 ][
+#     define SIZE_MAX  _UI32_MAX
+#  endif // _WIN64 ]
+#endif // SIZE_MAX ]
+
+// WCHAR_MIN and WCHAR_MAX are also defined in <wchar.h>
+#ifndef WCHAR_MIN // [
+#  define WCHAR_MIN  0
+#endif  // WCHAR_MIN ]
+#ifndef WCHAR_MAX // [
+#  define WCHAR_MAX  _UI16_MAX
+#endif  // WCHAR_MAX ]
+
+#define WINT_MIN  0
+#define WINT_MAX  _UI16_MAX
+
+#endif // __STDC_LIMIT_MACROS ]
+
+
+// 7.18.4 Limits of other integer types
+
+#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260
+
+// 7.18.4.1 Macros for minimum-width integer constants
+
+#define INT8_C(val)  val##i8
+#define INT16_C(val) val##i16
+#define INT32_C(val) val##i32
+#define INT64_C(val) val##i64
+
+#define UINT8_C(val)  val##ui8
+#define UINT16_C(val) val##ui16
+#define UINT32_C(val) val##ui32
+#define UINT64_C(val) val##ui64
+
+// 7.18.4.2 Macros for greatest-width integer constants
+#define INTMAX_C   INT64_C
+#define UINTMAX_C  UINT64_C
+
+#endif // __STDC_CONSTANT_MACROS ]
+
+
+#endif // _MSC_STDINT_H_ ]
diff --git a/re2/compile.cc b/re2/compile.cc
index 9cddb71..adb45fd 100644
--- a/re2/compile.cc
+++ b/re2/compile.cc
@@ -502,7 +502,7 @@ int Compiler::RuneByteSuffix(uint8 lo, uint8 hi, bool foldcase, int next) {
     return UncachedRuneByteSuffix(lo, hi, foldcase, next);
   }
 
-  uint64 key = ((uint64)next << 17) | (lo<<9) | (hi<<1) | foldcase;
+  uint64 key = ((uint64)next << 17) | (lo<<9) | (hi<<1) | (foldcase ? 1ULL : 0ULL);
   map<uint64, int>::iterator it = rune_cache_.find(key);
   if (it != rune_cache_.end())
     return it->second;
diff --git a/re2/prefilter_tree.cc b/re2/prefilter_tree.cc
index d8bc37a..cdcf77e 100644
--- a/re2/prefilter_tree.cc
+++ b/re2/prefilter_tree.cc
@@ -8,6 +8,11 @@
 #include "re2/prefilter_tree.h"
 #include "re2/re2.h"
 
+#ifdef WIN32
+#include <stdio.h>
+#define snprintf _snprintf
+#endif
+
 DEFINE_int32(filtered_re2_min_atom_len,
              3,
              "Strings less than this length are not stored as atoms");
diff --git a/re2/re2.cc b/re2/re2.cc
index 8d1d468..0da886d 100644
--- a/re2/re2.cc
+++ b/re2/re2.cc
@@ -11,7 +11,13 @@
 
 #include <stdio.h>
 #include <string>
+#ifdef WIN32
+#define strtoll _strtoi64
+#define strtoull _strtoui64
+#define strtof strtod
+#else
 #include <pthread.h>
+#endif
 #include <errno.h>
 #include "util/util.h"
 #include "util/flags.h"
@@ -31,10 +37,22 @@ const VariadicFunction2<bool, const StringPiece&, const RE2&, RE2::Arg, RE2::Par
 const VariadicFunction2<bool, StringPiece*, const RE2&, RE2::Arg, RE2::ConsumeN> RE2::Consume;
 const VariadicFunction2<bool, StringPiece*, const RE2&, RE2::Arg, RE2::FindAndConsumeN> RE2::FindAndConsume;
 
-// This will trigger LNK2005 error in MSVC.
-#ifndef COMPILER_MSVC
-const int RE2::Options::kDefaultMaxMem;  // initialized in re2.h
-#endif  // COMPILER_MSVC
+#define kDefaultMaxMem (8<<20)
+
+RE2::Options::Options()
+  :  encoding_(EncodingUTF8),
+     posix_syntax_(false),
+     longest_match_(false),
+     log_errors_(true),
+     max_mem_(kDefaultMaxMem),
+     literal_(false),
+     never_nl_(false),
+     never_capture_(false),
+     case_sensitive_(true),
+     perl_classes_(false),
+     word_boundary_(false),
+     one_line_(false) {
+}
 
 RE2::Options::Options(RE2::CannedOptions opt)
   : encoding_(opt == RE2::Latin1 ? EncodingLatin1 : EncodingUTF8),
diff --git a/re2/re2.h b/re2/re2.h
index 272028b..c509853 100644
--- a/re2/re2.h
+++ b/re2/re2.h
@@ -552,28 +552,16 @@ class RE2 {
     // If this happens too often, RE2 falls back on the NFA implementation.
 
     // For now, make the default budget something close to Code Search.
+#ifndef WIN32
     static const int kDefaultMaxMem = 8<<20;
+#endif
 
     enum Encoding {
       EncodingUTF8 = 1,
       EncodingLatin1
     };
 
-    Options() :
-      encoding_(EncodingUTF8),
-      posix_syntax_(false),
-      longest_match_(false),
-      log_errors_(true),
-      max_mem_(kDefaultMaxMem),
-      literal_(false),
-      never_nl_(false),
-      never_capture_(false),
-      case_sensitive_(true),
-      perl_classes_(false),
-      word_boundary_(false),
-      one_line_(false) {
-    }
-    
+    Options();
     /*implicit*/ Options(CannedOptions);
 
     Encoding encoding() const { return encoding_; }
diff --git a/re2/stringpiece.h b/re2/stringpiece.h
index ab9297c..38a5150 100644
--- a/re2/stringpiece.h
+++ b/re2/stringpiece.h
@@ -23,6 +23,9 @@
 #include <cstddef>
 #include <iosfwd>
 #include <string>
+#ifdef WIN32
+#include <algorithm>
+#endif
 
 namespace re2 {
 
diff --git a/re2/testing/re2_test.cc b/re2/testing/re2_test.cc
index b99cacf..911e868 100644
--- a/re2/testing/re2_test.cc
+++ b/re2/testing/re2_test.cc
@@ -6,7 +6,9 @@
 // TODO: Test extractions for PartialMatch/Consume
 
 #include <sys/types.h>
+#ifndef WIN32
 #include <sys/mman.h>
+#endif
 #include <sys/stat.h>
 #include <errno.h>
 #include <vector>
@@ -14,6 +16,11 @@
 #include "re2/re2.h"
 #include "re2/regexp.h"
 
+#ifdef WIN32
+#include <stdio.h>
+#define snprintf _snprintf
+#endif
+
 DECLARE_bool(logtostderr);
 
 namespace re2 {
@@ -657,6 +664,7 @@ TEST(RE2, FullMatchTypedNullArg) {
   CHECK(!RE2::FullMatch("hello", "(.*)", (float*)NULL));
 }
 
+#ifndef WIN32
 // Check that numeric parsing code does not read past the end of
 // the number being parsed.
 TEST(RE2, NULTerminated) {
@@ -678,6 +686,7 @@ TEST(RE2, NULTerminated) {
   CHECK(RE2::FullMatch(StringPiece(v + pagesize - 1, 1), "(.*)", &x));
   CHECK_EQ(x, 1);
 }
+#endif
 
 TEST(RE2, FullMatchTypeTests) {
   // Type tests
diff --git a/util/logging.h b/util/logging.h
index 4443f7c..d0a2d87 100644
--- a/util/logging.h
+++ b/util/logging.h
@@ -7,8 +7,13 @@
 #ifndef RE2_UTIL_LOGGING_H__
 #define RE2_UTIL_LOGGING_H__
 
+#ifndef WIN32
 #include <unistd.h>  /* for write */
+#endif
 #include <sstream>
+#ifdef WIN32
+#include <io.h>
+#endif
 
 // Debug-only checking.
 #define DCHECK(condition) assert(condition)
diff --git a/util/mutex.h b/util/mutex.h
index 9787bfb..e321fae 100644
--- a/util/mutex.h
+++ b/util/mutex.h
@@ -12,8 +12,10 @@
 
 namespace re2 {
 
+#ifndef WIN32
 #define HAVE_PTHREAD 1
 #define HAVE_RWLOCK 1
+#endif
 
 #if defined(NO_THREADS)
   typedef int MutexType;      // to keep a lock-count
@@ -32,7 +34,9 @@ namespace re2 {
 # include <pthread.h>
   typedef pthread_mutex_t MutexType;
 #elif defined(WIN32)
-# define WIN32_LEAN_AND_MEAN  // We only need minimal includes
+# ifndef WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN  // We only need minimal includes
+# endif
 # ifdef GMUTEX_TRYLOCK
   // We need Windows NT or later for TryEnterCriticalSection().  If you
   // don't need that functionality, you can remove these _WIN32_WINNT
diff --git a/util/pcre.cc b/util/pcre.cc
index 5e67e1f..1602133 100644
--- a/util/pcre.cc
+++ b/util/pcre.cc
@@ -11,6 +11,11 @@
 #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.
diff --git a/util/pcre.h b/util/pcre.h
index 4dda95d..771ac91 100644
--- a/util/pcre.h
+++ b/util/pcre.h
@@ -180,9 +180,15 @@ struct pcre_extra { int flags, match_limit, match_limit_recursion; };
 #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
 
diff --git a/util/stringprintf.cc b/util/stringprintf.cc
index c908181..d4691d1 100644
--- a/util/stringprintf.cc
+++ b/util/stringprintf.cc
@@ -4,6 +4,10 @@
 
 #include "util/util.h"
 
+#ifndef va_copy
+#define va_copy(d,s) ((d) = (s)) //KLUGE: for MS compilers
+#endif
+
 namespace re2 { 
 
 static void StringAppendV(string* dst, const char* format, va_list ap) {
diff --git a/util/test.cc b/util/test.cc
index 0644829..2fe1bfa 100644
--- a/util/test.cc
+++ b/util/test.cc
@@ -3,7 +3,9 @@
 // license that can be found in the LICENSE file.
 
 #include <stdio.h>
+#ifndef WIN32
 #include <sys/resource.h>
+#endif
 #include "util/test.h"
 
 DEFINE_string(test_tmpdir, "/var/tmp", "temp directory");
@@ -23,9 +25,13 @@ void RegisterTest(void (*fn)(void), const char *name) {
 
 namespace re2 {
 int64 VirtualProcessSize() {
+#ifndef WIN32
   struct rusage ru;
   getrusage(RUSAGE_SELF, &ru);
   return (int64)ru.ru_maxrss*1024;
+#else
+  return 0;
+#endif
 }
 }  // namespace re2
 
diff --git a/util/util.h b/util/util.h
index c46ab1b..17ef824 100644
--- a/util/util.h
+++ b/util/util.h
@@ -12,7 +12,9 @@
 #include <stddef.h>         // For size_t
 #include <assert.h>
 #include <stdarg.h>
+#ifndef WIN32
 #include <sys/time.h>
+#endif
 #include <time.h>
 #include <ctype.h>	// For isdigit, isalpha.
 
@@ -51,7 +53,11 @@ using std::tr1::unordered_set;
 #else
 
 #include <unordered_set>
+#ifdef WIN32
+using std::tr1::unordered_set;
+#else
 using std::unordered_set;
+#endif
 
 #endif
 
diff --git a/util/valgrind.h b/util/valgrind.h
index ca10b1a..d097b0c 100644
--- a/util/valgrind.h
+++ b/util/valgrind.h
@@ -4064,6 +4064,7 @@ typedef
 #endif /* PLAT_ppc64_aix5 */
 
 
+#ifndef WIN32
 /* ------------------------------------------------------------------ */
 /* ARCHITECTURE INDEPENDENT MACROS for CLIENT REQUESTS.               */
 /*                                                                    */
@@ -4170,7 +4171,7 @@ typedef
                                VG_USERREQ__DISCARD_TRANSLATIONS,  \
                                _qzz_addr, _qzz_len, 0, 0, 0);     \
    }
-
+#endif
 
 /* These requests are for getting Valgrind itself to print something.
    Possibly with a backtrace.  This is a really ugly hack.  The return value