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

webrtc/base/win32.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 64 matching lines @@
                       as_in_addr->S_un.S_un_b.s_b3,
                       as_in_addr->S_un.S_un_b.s_b4);
   return dst;
 }
 
 // Helper function for inet_ntop for IPv6 addresses.
 const char* inet_ntop_v6(const void* src, char* dst, socklen_t size) {
   if (size < INET6_ADDRSTRLEN) {
     return NULL;
   }
-  const uint16* as_shorts =
-      reinterpret_cast<const uint16*>(src);
+  const uint16_t* as_shorts = reinterpret_cast<const uint16_t*>(src);
   int runpos[8];
   int current = 1;
   int max = 0;
   int maxpos = -1;
   int run_array_size = ARRAY_SIZE(runpos);
   // Run over the address marking runs of 0s.
   for (int i = 0; i < run_array_size; ++i) {
     if (as_shorts[i] == 0) {
       runpos[i] = current;
       if (current > max) {
@@ skipping 110 matching lines @@
     if (c == 'x') {
       return 0;
     }
     c = *readcursor++;
   }
   readcursor = src;
 
   struct in6_addr an_addr;
   memset(&an_addr, 0, sizeof(an_addr));
 
-  uint16* addr_cursor = reinterpret_cast<uint16*>(&an_addr.s6_addr[0]);
-  uint16* addr_end = reinterpret_cast<uint16*>(&an_addr.s6_addr[16]);
+  uint16_t* addr_cursor = reinterpret_cast<uint16_t*>(&an_addr.s6_addr[0]);
+  uint16_t* addr_end = reinterpret_cast<uint16_t*>(&an_addr.s6_addr[16]);
   bool seencompressed = false;
 
   // Addresses that start with "::" (i.e., a run of initial zeros) or
   // "::ffff:" can potentially be IPv4 mapped or compatibility addresses.
   // These have dotted-style IPv4 addresses on the end (e.g. "::192.168.7.1").
   if (*readcursor == ':' && *(readcursor+1) == ':' &&
       *(readcursor + 2) != 0) {
     // Check for periods, which we'll take as a sign of v4 addresses.
     const char* addrstart = readcursor + 2;
     if (rtc::strchr(addrstart, ".")) {
       const char* colon = rtc::strchr(addrstart, "::");
       if (colon) {
-        uint16 a_short;
+        uint16_t a_short;
         int bytesread = 0;
         if (sscanf(addrstart, "%hx%n", &a_short, &bytesread) != 1 ||
             a_short != 0xFFFF || bytesread != 4) {
           // Colons + periods means has to be ::ffff:a.b.c.d. But it wasn't.
           return 0;
         } else {
           an_addr.s6_addr[10] = 0xFF;
           an_addr.s6_addr[11] = 0xFF;
           addrstart = colon + 1;
         }
@@ skipping 34 matching lines @@
             ++coloncounter;
           }
           // (coloncount + 1) is the number of shorts left in the address.
           addr_cursor = addr_end - (coloncount + 1);
           seencompressed = true;
         }
       } else {
         ++readcursor;
       }
     } else {
-      uint16 word;
+      uint16_t word;
       int bytesread = 0;
       if (sscanf(readcursor, "%hx%n", &word, &bytesread) != 1) {
         return 0;
       } else {
         *addr_cursor = HostToNetwork16(word);
         ++addr_cursor;
         readcursor += bytesread;
         if (*readcursor != ':' && *readcursor != '\0') {
           return 0;
         }
@@ skipping 58 matching lines @@
   FILETIME base_ft;
   SystemTimeToFileTime(&base_st, &base_ft);
 
   ULARGE_INTEGER base_ul;
   memcpy(&base_ul, &base_ft, sizeof(FILETIME));
 
   // Multiply by big number to convert to 100ns units, then add in the 1970
   // base date value.
   const ULONGLONG RATIO = 10000000;
   ULARGE_INTEGER current_ul;
-  current_ul.QuadPart = base_ul.QuadPart + static_cast<int64>(ut) * RATIO;
+  current_ul.QuadPart = base_ul.QuadPart + static_cast<int64_t>(ut) * RATIO;
   memcpy(ft, &current_ul, sizeof(FILETIME));
 }
 
 bool Utf8ToWindowsFilename(const std::string& utf8, std::wstring* filename) {
   // TODO: Integrate into fileutils.h
   // TODO: Handle wide and non-wide cases via TCHAR?
   // TODO: Skip \\?\ processing if the length is not > MAX_PATH?
   // TODO: Write unittests
 
   // Convert to Utf16
@@ skipping 72 matching lines @@
         *level = *GetSidSubAuthority(til->Label.Sid, count - 1);
         ret = true;
       }
     }
     CloseHandle(token);
   }
   return ret;
 }
 
 }  // namespace rtc