Use suffixed {uint,int}{8,16,32,64}_t types.

webrtc/base/md5.cc

 /*
  * This code implements the MD5 message-digest algorithm.
  * The algorithm is due to Ron Rivest.  This code was
  * written by Colin Plumb in 1993, no copyright is claimed.
  * This code is in the public domain; do with it what you wish.
  *
  * Equivalent code is available from RSA Data Security, Inc.
  * This code has been tested against that, and is equivalent,
  * except that you don't need to include two pages of legalese
  * with every copy.
@@ skipping 12 matching lines @@
 // TODO: Avoid memcmpy - hash directly from memory.
 #include <string.h>  // for memcpy().
 
 #include "webrtc/base/byteorder.h"  // for RTC_ARCH_CPU_LITTLE_ENDIAN.
 
 namespace rtc {
 
 #ifdef RTC_ARCH_CPU_LITTLE_ENDIAN
 #define ByteReverse(buf, len)  // Nothing.
 #else  // RTC_ARCH_CPU_BIG_ENDIAN
-static void ByteReverse(uint32* buf, int len) {
+static void ByteReverse(uint32_t* buf, int len) {
   for (int i = 0; i < len; ++i) {
     buf[i] = rtc::GetLE32(&buf[i]);
   }
 }
 #endif
 
 // Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
 // initialization constants.
 void MD5Init(MD5Context* ctx) {
   ctx->buf[0] = 0x67452301;
   ctx->buf[1] = 0xefcdab89;
   ctx->buf[2] = 0x98badcfe;
   ctx->buf[3] = 0x10325476;
   ctx->bits[0] = 0;
   ctx->bits[1] = 0;
 }
 
 // Update context to reflect the concatenation of another buffer full of bytes.
-void MD5Update(MD5Context* ctx, const uint8* buf, size_t len) {
+void MD5Update(MD5Context* ctx, const uint8_t* buf, size_t len) {
   // Update bitcount.
-  uint32 t = ctx->bits[0];
-  if ((ctx->bits[0] = t + (static_cast<uint32>(len) << 3)) < t) {
+  uint32_t t = ctx->bits[0];
+  if ((ctx->bits[0] = t + (static_cast<uint32_t>(len) << 3)) < t) {
     ctx->bits[1]++;  // Carry from low to high.
   }
-  ctx->bits[1] += static_cast<uint32>(len >> 29);
+  ctx->bits[1] += static_cast<uint32_t>(len >> 29);
   t = (t >> 3) & 0x3f;  // Bytes already in shsInfo->data.
 
   // Handle any leading odd-sized chunks.
   if (t) {
-    uint8* p = reinterpret_cast<uint8*>(ctx->in) + t;
+    uint8_t* p = reinterpret_cast<uint8_t*>(ctx->in) + t;
 
     t = 64-t;
     if (len < t) {
       memcpy(p, buf, len);
       return;
     }
     memcpy(p, buf, t);
     ByteReverse(ctx->in, 16);
     MD5Transform(ctx->buf, ctx->in);
     buf += t;
     len -= t;
   }
 
   // Process data in 64-byte chunks.
   while (len >= 64) {
     memcpy(ctx->in, buf, 64);
     ByteReverse(ctx->in, 16);
     MD5Transform(ctx->buf, ctx->in);
     buf += 64;
     len -= 64;
   }
 
   // Handle any remaining bytes of data.
   memcpy(ctx->in, buf, len);
 }
 
 // Final wrapup - pad to 64-byte boundary with the bit pattern.
 // 1 0* (64-bit count of bits processed, MSB-first)
-void MD5Final(MD5Context* ctx, uint8 digest[16]) {
+void MD5Final(MD5Context* ctx, uint8_t digest[16]) {
   // Compute number of bytes mod 64.
-  uint32 count = (ctx->bits[0] >> 3) & 0x3F;
+  uint32_t count = (ctx->bits[0] >> 3) & 0x3F;
 
   // Set the first char of padding to 0x80.  This is safe since there is
   // always at least one byte free.
-  uint8* p = reinterpret_cast<uint8*>(ctx->in) + count;
+  uint8_t* p = reinterpret_cast<uint8_t*>(ctx->in) + count;
   *p++ = 0x80;
 
   // Bytes of padding needed to make 64 bytes.
   count = 64 - 1 - count;
 
   // Pad out to 56 mod 64.
   if (count < 8) {
     // Two lots of padding:  Pad the first block to 64 bytes.
     memset(p, 0, count);
     ByteReverse(ctx->in, 16);
@@ skipping 24 matching lines @@
 #define F3(x, y, z) (x ^ y ^ z)
 #define F4(x, y, z) (y ^ (x | ~z))
 
 // This is the central step in the MD5 algorithm.
 #define MD5STEP(f, w, x, y, z, data, s) \
     (w += f(x, y, z) + data, w = w << s | w >> (32 - s), w += x)
 
 // The core of the MD5 algorithm, this alters an existing MD5 hash to
 // reflect the addition of 16 longwords of new data.  MD5Update blocks
 // the data and converts bytes into longwords for this routine.
-void MD5Transform(uint32 buf[4], const uint32 in[16]) {
-  uint32 a = buf[0];
-  uint32 b = buf[1];
-  uint32 c = buf[2];
-  uint32 d = buf[3];
+void MD5Transform(uint32_t buf[4], const uint32_t in[16]) {
+  uint32_t a = buf[0];
+  uint32_t b = buf[1];
+  uint32_t c = buf[2];
+  uint32_t d = buf[3];
 
   MD5STEP(F1, a, b, c, d, in[ 0] + 0xd76aa478, 7);
   MD5STEP(F1, d, a, b, c, in[ 1] + 0xe8c7b756, 12);
   MD5STEP(F1, c, d, a, b, in[ 2] + 0x242070db, 17);
   MD5STEP(F1, b, c, d, a, in[ 3] + 0xc1bdceee, 22);
   MD5STEP(F1, a, b, c, d, in[ 4] + 0xf57c0faf, 7);
   MD5STEP(F1, d, a, b, c, in[ 5] + 0x4787c62a, 12);
   MD5STEP(F1, c, d, a, b, in[ 6] + 0xa8304613, 17);
   MD5STEP(F1, b, c, d, a, in[ 7] + 0xfd469501, 22);
   MD5STEP(F1, a, b, c, d, in[ 8] + 0x698098d8, 7);
@@ skipping 55 matching lines @@
   MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
   MD5STEP(F4, c, d, a, b, in[ 2] + 0x2ad7d2bb, 15);
   MD5STEP(F4, b, c, d, a, in[ 9] + 0xeb86d391, 21);
   buf[0] += a;
   buf[1] += b;
   buf[2] += c;
   buf[3] += d;
 }
 
 }  // namespace rtc