Revert of Update re2

third_party/re2/util/rune.cc

 /*
  * The authors of this software are Rob Pike and Ken Thompson.
  *              Copyright (c) 2002 by Lucent Technologies.
  * Permission to use, copy, modify, and distribute this software for any
  * purpose without fee is hereby granted, provided that this entire notice
  * is included in all copies of any software which is or includes a copy
  * or modification of this software and in all copies of the supporting
  * documentation for such software.
  * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
  * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
@@ skipping 115 matching lines @@
 {
         /* Runes are signed, so convert to unsigned for range check. */
         unsigned long c;
 
         /*
          * one character sequence
          *      00000-0007F => 00-7F
          */
         c = *rune;
         if(c <= Rune1) {
-                str[0] = static_cast<char>(c);
+                str[0] = c;
                 return 1;
         }
 
         /*
          * two character sequence
          *      0080-07FF => T2 Tx
          */
         if(c <= Rune2) {
-                str[0] = T2 | static_cast<char>(c >> 1*Bitx);
+                str[0] = T2 | (c >> 1*Bitx);
                 str[1] = Tx | (c & Maskx);
                 return 2;
         }
 
         /*
          * If the Rune is out of range, convert it to the error rune.
          * Do this test here because the error rune encodes to three bytes.
          * Doing it earlier would duplicate work, since an out of range
          * Rune wouldn't have fit in one or two bytes.
          */
         if (c > Runemax)
                 c = Runeerror;
 
         /*
          * three character sequence
          *      0800-FFFF => T3 Tx Tx
          */
         if (c <= Rune3) {
-                str[0] = T3 | static_cast<char>(c >> 2*Bitx);
+                str[0] = T3 |  (c >> 2*Bitx);
                 str[1] = Tx | ((c >> 1*Bitx) & Maskx);
-                str[2] = Tx | (c & Maskx);
+                str[2] = Tx |  (c & Maskx);
                 return 3;
         }
 
         /*
          * four character sequence (21-bit value)
          *     10000-1FFFFF => T4 Tx Tx Tx
          */
-        str[0] = T4 | static_cast<char>(c >> 3*Bitx);
+        str[0] = T4 | (c >> 3*Bitx);
         str[1] = Tx | ((c >> 2*Bitx) & Maskx);
         str[2] = Tx | ((c >> 1*Bitx) & Maskx);
         str[3] = Tx | (c & Maskx);
         return 4;
 }
 
 int
 runelen(Rune rune)
 {
         char str[10];
@@ skipping 64 matching lines @@
                 }
                 n = chartorune(&r, s);
                 if(r == c)
                         return (char*)s;
                 s += n;
         }
         return 0;
 }
 
 }  // namespace re2