Update re2

third_party/re2/re2/re2.h

 // Copyright 2003-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.
 
 #ifndef RE2_RE2_H
 #define RE2_RE2_H
 
 // C++ interface to the re2 regular-expression library.
 // RE2 supports Perl-style regular expressions (with extensions like
 // \d, \w, \s, ...).
 //
 // -----------------------------------------------------------------------
 // REGEXP SYNTAX:
 //
 // This module uses the re2 library and hence supports
 // its syntax for regular expressions, which is similar to Perl's with
 // some of the more complicated things thrown away.  In particular,
 // backreferences and generalized assertions are not available, nor is \Z.
 //
-// See http://code.google.com/p/re2/wiki/Syntax for the syntax
+// See https://github.com/google/re2/wiki/Syntax for the syntax
 // supported by RE2, and a comparison with PCRE and PERL regexps.
 //
 // For those not familiar with Perl's regular expressions,
 // here are some examples of the most commonly used extensions:
 //
 //   "hello (\\w+) world"  -- \w matches a "word" character
 //   "version (\\d+)"      -- \d matches a digit
 //   "hello\\s+world"      -- \s matches any whitespace character
 //   "\\b(\\w+)\\b"        -- \b matches non-empty string at word boundary
 //   "(?i)hello"           -- (?i) turns on case-insensitive matching
@@ skipping 141 matching lines @@
 // Octal(), or CRadix() to interpret the text in another base.  The
 // CRadix operator interprets C-style "0" (base-8) and "0x" (base-16)
 // prefixes, but defaults to base-10.
 //
 // Example:
 //   int a, b, c, d;
 //   CHECK(RE2::FullMatch("100 40 0100 0x40", "(.*) (.*) (.*) (.*)",
 //         RE2::Octal(&a), RE2::Hex(&b), RE2::CRadix(&c), RE2::CRadix(&d));
 // will leave 64 in a, b, c, and d.
 
-
 #include <stdint.h>
 #include <map>
 #include <string>
 #include "re2/stringpiece.h"
 #include "re2/variadic_function.h"
 
+#ifndef RE2_HAVE_LONGLONG
+#define RE2_HAVE_LONGLONG 1
+#endif
+
 namespace re2 {
 
 using std::string;
 using std::map;
 class Mutex;
 class Prog;
 class Regexp;
 
 // The following enum should be used only as a constructor argument to indicate
 // that the variable has static storage class, and that the constructor should
@@ skipping 34 matching lines @@
     ErrorBadCharRange,       // bad character class range
     ErrorMissingBracket,     // missing closing ]
     ErrorMissingParen,       // missing closing )
     ErrorTrailingBackslash,  // trailing \ at end of regexp
     ErrorRepeatArgument,     // repeat argument missing, e.g. "*"
     ErrorRepeatSize,         // bad repetition argument
     ErrorRepeatOp,           // bad repetition operator
     ErrorBadPerlOp,          // bad perl operator
     ErrorBadUTF8,            // invalid UTF-8 in regexp
     ErrorBadNamedCapture,    // bad named capture group
-    ErrorPatternTooLarge,    // pattern too large (compile failed)
+    ErrorPatternTooLarge     // pattern too large (compile failed)
   };
 
   // Predefined common options.
   // If you need more complicated things, instantiate
   // an Option class, possibly passing one of these to
   // the Option constructor, change the settings, and pass that
   // Option class to the RE2 constructor.
   enum CannedOptions {
     DefaultOptions = 0,
     Latin1, // treat input as Latin-1 (default UTF-8)
@@ skipping 29 matching lines @@
   ErrorCode error_code() const { return error_code_; }
 
   // If RE2 could not be created properly, returns the offending
   // portion of the regexp.
   const string& error_arg() const { return error_arg_; }
 
   // Returns the program size, a very approximate measure of a regexp's "cost".
   // Larger numbers are more expensive than smaller numbers.
   int ProgramSize() const;
 
+  // EXPERIMENTAL! SUBJECT TO CHANGE!
+  // Outputs the program fanout as a histogram bucketed by powers of 2.
+  // Returns the number of the largest non-empty bucket.
+  int ProgramFanout(map<int, int>* histogram) const;
+
   // Returns the underlying Regexp; not for general use.
   // Returns entire_regexp_ so that callers don't need
   // to know about prefix_ and prefix_foldcase_.
   re2::Regexp* Regexp() const { return entire_regexp_; }
 
   /***** The useful part: the matching interface *****/
 
   // Matches "text" against "pattern".  If pointer arguments are
   // supplied, copies matched sub-patterns into them.
   //
@@ skipping 84 matching lines @@
   static int GlobalReplace(string *str,
                            const RE2& pattern,
                            const StringPiece& rewrite);
 
   // Like Replace, except that if the pattern matches, "rewrite"
   // is copied into "out" with substitutions.  The non-matching
   // portions of "text" are ignored.
   //
   // Returns true iff a match occurred and the extraction happened
   // successfully;  if no match occurs, the string is left unaffected.
+  //
+  // REQUIRES: "text" must not alias any part of "*out".
   static bool Extract(const StringPiece &text,
                       const RE2& pattern,
                       const StringPiece &rewrite,
                       string *out);
 
   // Escapes all potentially meaningful regexp characters in
   // 'unquoted'.  The returned string, used as a regular expression,
   // will exactly match the original string.  For example,
   //           1.5-2.0?
   // may become:
@@ skipping 15 matching lines @@
   //
   // Returns true on success, false on error.
   bool PossibleMatchRange(string* min, string* max, int maxlen) const;
 
   // Generic matching interface
 
   // Type of match.
   enum Anchor {
     UNANCHORED,         // No anchoring
     ANCHOR_START,       // Anchor at start only
-    ANCHOR_BOTH,        // Anchor at start and end
+    ANCHOR_BOTH         // Anchor at start and end
   };
 
   // Return the number of capturing subpatterns, or -1 if the
   // regexp wasn't valid on construction.  The overall match ($0)
   // does not count: if the regexp is "(a)(b)", returns 2.
   int NumberOfCapturingGroups() const;
 
-
   // Return a map from names to capturing indices.
   // The map records the index of the leftmost group
   // with the given name.
   // Only valid until the re is deleted.
   const map<string, int>& NamedCapturingGroups() const;
 
   // Return a map from capturing indices to names.
   // The map has no entries for unnamed groups.
   // Only valid until the re is deleted.
   const map<int, string>& CapturingGroupNames() const;
@@ skipping 54 matching lines @@
    public:
     // The options are (defaults in parentheses):
     //
     //   utf8             (true)  text and pattern are UTF-8; otherwise Latin-1
     //   posix_syntax     (false) restrict regexps to POSIX egrep syntax
     //   longest_match    (false) search for longest match, not first match
     //   log_errors       (true)  log syntax and execution errors to ERROR
     //   max_mem          (see below)  approx. max memory footprint of RE2
     //   literal          (false) interpret string as literal, not regexp
     //   never_nl         (false) never match \n, even if it is in regexp
+    //   dot_nl           (false) dot matches everything including new line
     //   never_capture    (false) parse all parens as non-capturing
     //   case_sensitive   (true)  match is case-sensitive (regexp can override
     //                              with (?i) unless in posix_syntax mode)
     //
     // The following options are only consulted when posix_syntax == true.
     // (When posix_syntax == false these features are always enabled and
     // cannot be turned off.)
     //   perl_classes     (false) allow Perl's \d \s \w \D \S \W
     //   word_boundary    (false) allow Perl's \b \B (word boundary and not)
     //   one_line         (false) ^ and $ only match beginning and end of text
@@ skipping 20 matching lines @@
     // The RE2 memory budget is statically divided between the two
     // Progs and then the DFAs: two thirds to the forward Prog
     // and one third to the reverse Prog.  The forward Prog gives half
     // of what it has left over to each of its DFAs.  The reverse Prog
     // gives it all to its longest-match DFA.
     //
     // Once a DFA fills its budget, it flushes its cache and starts over.
     // 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();
+    Options() :
+      encoding_(EncodingUTF8),
+      posix_syntax_(false),
+      longest_match_(false),
+      log_errors_(true),
+      max_mem_(kDefaultMaxMem),
+      literal_(false),
+      never_nl_(false),
+      dot_nl_(false),
+      never_capture_(false),
+      case_sensitive_(true),
+      perl_classes_(false),
+      word_boundary_(false),
+      one_line_(false) {
+    }
+
     /*implicit*/ Options(CannedOptions);
 
     Encoding encoding() const { return encoding_; }
     void set_encoding(Encoding encoding) { encoding_ = encoding; }
 
     // Legacy interface to encoding.
     // TODO(rsc): Remove once clients have been converted.
     bool utf8() const { return encoding_ == EncodingUTF8; }
     void set_utf8(bool b) {
       if (b) {
         encoding_ = EncodingUTF8;
       } else {
         encoding_ = EncodingLatin1;
       }
     }
 
     bool posix_syntax() const { return posix_syntax_; }
     void set_posix_syntax(bool b) { posix_syntax_ = b; }
 
     bool longest_match() const { return longest_match_; }
     void set_longest_match(bool b) { longest_match_ = b; }
 
     bool log_errors() const { return log_errors_; }
     void set_log_errors(bool b) { log_errors_ = b; }
 
-    int max_mem() const { return max_mem_; }
-    void set_max_mem(int m) { max_mem_ = m; }
+    int64_t max_mem() const { return max_mem_; }
+    void set_max_mem(int64_t m) { max_mem_ = m; }
 
     bool literal() const { return literal_; }
     void set_literal(bool b) { literal_ = b; }
 
     bool never_nl() const { return never_nl_; }
     void set_never_nl(bool b) { never_nl_ = b; }
 
+    bool dot_nl() const { return dot_nl_; }
+    void set_dot_nl(bool b) { dot_nl_ = b; }
+
     bool never_capture() const { return never_capture_; }
     void set_never_capture(bool b) { never_capture_ = b; }
 
     bool case_sensitive() const { return case_sensitive_; }
     void set_case_sensitive(bool b) { case_sensitive_ = b; }
 
     bool perl_classes() const { return perl_classes_; }
     void set_perl_classes(bool b) { perl_classes_ = b; }
 
     bool word_boundary() const { return word_boundary_; }
     void set_word_boundary(bool b) { word_boundary_ = b; }
 
     bool one_line() const { return one_line_; }
     void set_one_line(bool b) { one_line_ = b; }
 
     void Copy(const Options& src) {
       encoding_ = src.encoding_;
       posix_syntax_ = src.posix_syntax_;
       longest_match_ = src.longest_match_;
       log_errors_ = src.log_errors_;
       max_mem_ = src.max_mem_;
       literal_ = src.literal_;
       never_nl_ = src.never_nl_;
+      dot_nl_ = src.dot_nl_;
       never_capture_ = src.never_capture_;
       case_sensitive_ = src.case_sensitive_;
       perl_classes_ = src.perl_classes_;
       word_boundary_ = src.word_boundary_;
       one_line_ = src.one_line_;
     }
 
     int ParseFlags() const;
 
    private:
     Encoding encoding_;
     bool posix_syntax_;
     bool longest_match_;
     bool log_errors_;
     int64_t max_mem_;
     bool literal_;
     bool never_nl_;
+    bool dot_nl_;
     bool never_capture_;
     bool case_sensitive_;
     bool perl_classes_;
     bool word_boundary_;
     bool one_line_;
 
-    //DISALLOW_EVIL_CONSTRUCTORS(Options);
+    //DISALLOW_COPY_AND_ASSIGN(Options);
     Options(const Options&);
     void operator=(const Options&);
   };
 
   // Returns the options set in the constructor.
   const Options& options() const { return options_; };
 
   // Argument converters; see below.
   static inline Arg CRadix(short* x);
   static inline Arg CRadix(unsigned short* x);
   static inline Arg CRadix(int* x);
   static inline Arg CRadix(unsigned int* x);
   static inline Arg CRadix(long* x);
   static inline Arg CRadix(unsigned long* x);
+  #if RE2_HAVE_LONGLONG
   static inline Arg CRadix(long long* x);
   static inline Arg CRadix(unsigned long long* x);
+  #endif
 
   static inline Arg Hex(short* x);
   static inline Arg Hex(unsigned short* x);
   static inline Arg Hex(int* x);
   static inline Arg Hex(unsigned int* x);
   static inline Arg Hex(long* x);
   static inline Arg Hex(unsigned long* x);
+  #if RE2_HAVE_LONGLONG
   static inline Arg Hex(long long* x);
   static inline Arg Hex(unsigned long long* x);
+  #endif
 
   static inline Arg Octal(short* x);
   static inline Arg Octal(unsigned short* x);
   static inline Arg Octal(int* x);
   static inline Arg Octal(unsigned int* x);
   static inline Arg Octal(long* x);
   static inline Arg Octal(unsigned long* x);
+  #if RE2_HAVE_LONGLONG
   static inline Arg Octal(long long* x);
   static inline Arg Octal(unsigned long long* x);
+  #endif
 
  private:
   void Init(const StringPiece& pattern, const Options& options);
 
   bool DoMatch(const StringPiece& text,
                    Anchor anchor,
                    int* consumed,
                    const Arg* const args[],
                    int n) const;
 
@@ skipping 14 matching lines @@
   mutable ErrorCode        error_code_;    // Error code
   mutable string           error_arg_;     // Fragment of regexp showing error
   mutable int              num_captures_;  // Number of capturing groups
 
   // Map from capture names to indices
   mutable const map<string, int>* named_groups_;
 
   // Map from capture indices to names
   mutable const map<int, string>* group_names_;
 
-  //DISALLOW_EVIL_CONSTRUCTORS(RE2);
+  //DISALLOW_COPY_AND_ASSIGN(RE2);
   RE2(const RE2&);
   void operator=(const RE2&);
 };
 
 /***** Implementation details *****/
 
 // Hex/Octal/Binary?
 
 // Special class for parsing into objects that define a ParseFrom() method
 template <class T>
@@ skipping 24 matching lines @@
 
   MAKE_PARSER(char,               parse_char);
   MAKE_PARSER(signed char,        parse_char);
   MAKE_PARSER(unsigned char,      parse_uchar);
   MAKE_PARSER(short,              parse_short);
   MAKE_PARSER(unsigned short,     parse_ushort);
   MAKE_PARSER(int,                parse_int);
   MAKE_PARSER(unsigned int,       parse_uint);
   MAKE_PARSER(long,               parse_long);
   MAKE_PARSER(unsigned long,      parse_ulong);
+  #if RE2_HAVE_LONGLONG
   MAKE_PARSER(long long,          parse_longlong);
   MAKE_PARSER(unsigned long long, parse_ulonglong);
+  #endif
   MAKE_PARSER(float,              parse_float);
   MAKE_PARSER(double,             parse_double);
   MAKE_PARSER(string,             parse_string);
   MAKE_PARSER(StringPiece,        parse_stringpiece);
 
 #undef MAKE_PARSER
 
-  // Generic constructor
-  template <class T> Arg(T*, Parser parser);
-  // Generic constructor template
+  // Generic constructor templates
   template <class T> Arg(T* p)
-    : arg_(p), parser_(_RE2_MatchObject<T>::Parse) {
-  }
+      : arg_(p), parser_(_RE2_MatchObject<T>::Parse) { }
+  template <class T> Arg(T* p, Parser parser)
+      : arg_(p), parser_(parser) { }
 
   // Parse the data
   bool Parse(const char* str, int n) const;
 
  private:
   void*         arg_;
   Parser        parser_;
 
   static bool parse_null          (const char* str, int n, void* dest);
   static bool parse_char          (const char* str, int n, void* dest);
@@ skipping 12 matching lines @@
   static bool parse_ ## name ## _hex(const char* str, int n, void* dest);   \
   static bool parse_ ## name ## _octal(const char* str, int n, void* dest); \
   static bool parse_ ## name ## _cradix(const char* str, int n, void* dest)
 
   DECLARE_INTEGER_PARSER(short);
   DECLARE_INTEGER_PARSER(ushort);
   DECLARE_INTEGER_PARSER(int);
   DECLARE_INTEGER_PARSER(uint);
   DECLARE_INTEGER_PARSER(long);
   DECLARE_INTEGER_PARSER(ulong);
+  #if RE2_HAVE_LONGLONG
   DECLARE_INTEGER_PARSER(longlong);
   DECLARE_INTEGER_PARSER(ulonglong);
+  #endif
 
 #undef DECLARE_INTEGER_PARSER
 };
 
 inline RE2::Arg::Arg() : arg_(NULL), parser_(parse_null) { }
 inline RE2::Arg::Arg(void* p) : arg_(p), parser_(parse_null) { }
 
 inline bool RE2::Arg::Parse(const char* str, int n) const {
   return (*parser_)(str, n, arg_);
 }
 
 // This part of the parser, appropriate only for ints, deals with bases
 #define MAKE_INTEGER_PARSER(type, name) \
   inline RE2::Arg RE2::Hex(type* ptr) { \
     return RE2::Arg(ptr, RE2::Arg::parse_ ## name ## _hex); } \
   inline RE2::Arg RE2::Octal(type* ptr) { \
     return RE2::Arg(ptr, RE2::Arg::parse_ ## name ## _octal); } \
   inline RE2::Arg RE2::CRadix(type* ptr) { \
     return RE2::Arg(ptr, RE2::Arg::parse_ ## name ## _cradix); }
 
-MAKE_INTEGER_PARSER(short,              short);
-MAKE_INTEGER_PARSER(unsigned short,     ushort);
-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);
+MAKE_INTEGER_PARSER(short,              short)
+MAKE_INTEGER_PARSER(unsigned short,     ushort)
+MAKE_INTEGER_PARSER(int,                int)
+MAKE_INTEGER_PARSER(unsigned int,       uint)
+MAKE_INTEGER_PARSER(long,               long)
+MAKE_INTEGER_PARSER(unsigned long,      ulong)
+#if RE2_HAVE_LONGLONG
+MAKE_INTEGER_PARSER(long long,          longlong)
+MAKE_INTEGER_PARSER(unsigned long long, ulonglong)
+#endif
 
 #undef MAKE_INTEGER_PARSER
 
 }  // namespace re2
 
 using re2::RE2;
 
 #endif /* RE2_RE2_H */