Revert of Update re2

third_party/re2/re2/tostring.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.
 
 // Format a regular expression structure as a string.
 // Tested by parse_test.cc
 
 #include "util/util.h"
 #include "re2/regexp.h"
 #include "re2/walker-inl.h"
@@ skipping 24 matching lines @@
   virtual int PreVisit(Regexp* re, int parent_arg, bool* stop);
   virtual int PostVisit(Regexp* re, int parent_arg, int pre_arg,
                         int* child_args, int nchild_args);
   virtual int ShortVisit(Regexp* re, int parent_arg) {
     return 0;
   }
 
  private:
   string* t_;  // The string the walker appends to.
 
-  DISALLOW_COPY_AND_ASSIGN(ToStringWalker);
+  DISALLOW_EVIL_CONSTRUCTORS(ToStringWalker);
 };
 
 string Regexp::ToString() {
   string t;
   ToStringWalker w(&t);
   w.WalkExponential(this, PrecToplevel, 100000);
   if (w.stopped_early())
     t += " [truncated]";
   return t;
 }
@@ skipping 31 matching lines @@
       break;
 
     case kRegexpAlternate:
       if (prec < PrecAlternate)
         t_->append("(?:");
       nprec = PrecAlternate;
       break;
 
     case kRegexpCapture:
       t_->append("(");
-      if (re->cap() == 0)
-        LOG(DFATAL) << "kRegexpCapture cap() == 0";
       if (re->name()) {
         t_->append("?P<");
         t_->append(*re->name());
         t_->append(">");
       }
       nprec = PrecParen;
       break;
 
     case kRegexpStar:
     case kRegexpPlus:
     case kRegexpQuest:
     case kRegexpRepeat:
       if (prec < PrecUnary)
         t_->append("(?:");
       // The subprecedence here is PrecAtom instead of PrecUnary
       // because PCRE treats two unary ops in a row as a parse error.
       nprec = PrecAtom;
       break;
   }
 
   return nprec;
 }
 
 static void AppendLiteral(string *t, Rune r, bool foldcase) {
   if (r != 0 && r < 0x80 && strchr("(){}[]*+?|.^$\\", r)) {
     t->append(1, '\\');
-    t->append(1, static_cast<char>(r));
+    t->append(1, r);
   } else if (foldcase && 'a' <= r && r <= 'z') {
     if ('a' <= r && r <= 'z')
       r += 'A' - 'a';
     t->append(1, '[');
-    t->append(1, static_cast<char>(r));
-    t->append(1, static_cast<char>(r) + 'a' - 'A');
+    t->append(1, r);
+    t->append(1, r + 'a' - 'A');
     t->append(1, ']');
   } else {
     AppendCCRange(t, r, r);
   }
 }
 
 // Visits re after children are processed.
 // For childless regexps, all the work is done here.
 // For regexps with children, append any unary suffixes or ).
 int ToStringWalker::PostVisit(Regexp* re, int parent_arg, int pre_arg,
                               int* child_args, int nchild_args) {
   int prec = parent_arg;
   switch (re->op()) {
     case kRegexpNoMatch:
       // There's no simple symbol for "no match", but
       // [^0-Runemax] excludes everything.
       t_->append("[^\\x00-\\x{10ffff}]");
       break;
 
     case kRegexpEmptyMatch:
       // Append (?:) to make empty string visible,
       // unless this is already being parenthesized.
       if (prec < PrecEmpty)
         t_->append("(?:)");
       break;
 
     case kRegexpLiteral:
-      AppendLiteral(t_, re->rune(),
-                    (re->parse_flags() & Regexp::FoldCase) != 0);
+      AppendLiteral(t_, re->rune(), re->parse_flags() & Regexp::FoldCase);
       break;
 
     case kRegexpLiteralString:
       for (int i = 0; i < re->nrunes(); i++)
-        AppendLiteral(t_, re->runes()[i],
-                      (re->parse_flags() & Regexp::FoldCase) != 0);
+        AppendLiteral(t_, re->runes()[i], re->parse_flags() & Regexp::FoldCase);
       if (prec < PrecConcat)
         t_->append(")");
       break;
 
     case kRegexpConcat:
       if (prec < PrecConcat)
         t_->append(")");
       break;
 
     case kRegexpAlternate:
@@ skipping 117 matching lines @@
     t_->append("|");
 
   return 0;
 }
 
 // Appends a rune for use in a character class to the string t.
 static void AppendCCChar(string* t, Rune r) {
   if (0x20 <= r && r <= 0x7E) {
     if (strchr("[]^-\\", r))
       t->append("\\");
-    t->append(1, static_cast<char>(r));
+    t->append(1, r);
     return;
   }
   switch (r) {
     default:
       break;
 
     case '\r':
       t->append("\\r");
       return;
 
@@ skipping 21 matching lines @@
   if (lo > hi)
     return;
   AppendCCChar(t, lo);
   if (lo < hi) {
     t->append("-");
     AppendCCChar(t, hi);
   }
 }
 
 }  // namespace re2