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

webrtc/base/ipaddress.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 25 matching lines @@
 // Prefixes used for categorizing IPv6 addresses.
 static const in6_addr kV4MappedPrefix = {{{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                            0xFF, 0xFF, 0}}};
 static const in6_addr k6To4Prefix = {{{0x20, 0x02, 0}}};
 static const in6_addr kTeredoPrefix = {{{0x20, 0x01, 0x00, 0x00}}};
 static const in6_addr kV4CompatibilityPrefix = {{{0}}};
 static const in6_addr k6BonePrefix = {{{0x3f, 0xfe, 0}}};
 
 bool IPAddress::strip_sensitive_ = false;
 
-static bool IsPrivateV4(uint32 ip);
+static bool IsPrivateV4(uint32_t ip);
 static in_addr ExtractMappedAddress(const in6_addr& addr);
 
-uint32 IPAddress::v4AddressAsHostOrderInteger() const {
+uint32_t IPAddress::v4AddressAsHostOrderInteger() const {
   if (family_ == AF_INET) {
     return NetworkToHost32(u_.ip4.s_addr);
   } else {
     return 0;
   }
 }
 
 bool IPAddress::IsNil() const {
   return IPIsUnspec(*this);
 }
@@ skipping 148 matching lines @@
 
 std::ostream& operator<<(std::ostream& os, const InterfaceAddress& ip) {
   os << static_cast<const IPAddress&>(ip);
 
   if (ip.family() == AF_INET6)
     os << "|flags:0x" << std::hex << ip.ipv6_flags();
 
   return os;
 }
 
-bool IsPrivateV4(uint32 ip_in_host_order) {
+bool IsPrivateV4(uint32_t ip_in_host_order) {
   return ((ip_in_host_order >> 24) == 127) ||
       ((ip_in_host_order >> 24) == 10) ||
       ((ip_in_host_order >> 20) == ((172 << 4) | 1)) ||
       ((ip_in_host_order >> 16) == ((192 << 8) | 168)) ||
       ((ip_in_host_order >> 16) == ((169 << 8) | 254));
 }
 
 in_addr ExtractMappedAddress(const in6_addr& in6) {
   in_addr ipv4;
   ::memcpy(&ipv4.s_addr, &in6.s6_addr[12], sizeof(ipv4.s_addr));
@@ skipping 85 matching lines @@
   return ip.family() == AF_UNSPEC;
 }
 
 size_t HashIP(const IPAddress& ip) {
   switch (ip.family()) {
     case AF_INET: {
       return ip.ipv4_address().s_addr;
     }
     case AF_INET6: {
       in6_addr v6addr = ip.ipv6_address();
-      const uint32* v6_as_ints =
-          reinterpret_cast<const uint32*>(&v6addr.s6_addr);
+      const uint32_t* v6_as_ints =
+          reinterpret_cast<const uint32_t*>(&v6addr.s6_addr);
       return v6_as_ints[0] ^ v6_as_ints[1] ^ v6_as_ints[2] ^ v6_as_ints[3];
     }
   }
   return 0;
 }
 
 IPAddress TruncateIP(const IPAddress& ip, int length) {
   if (length < 0) {
     return IPAddress();
   }
   if (ip.family() == AF_INET) {
     if (length > 31) {
       return ip;
     }
     if (length == 0) {
       return IPAddress(INADDR_ANY);
     }
     int mask = (0xFFFFFFFF << (32 - length));
-    uint32 host_order_ip = NetworkToHost32(ip.ipv4_address().s_addr);
+    uint32_t host_order_ip = NetworkToHost32(ip.ipv4_address().s_addr);
     in_addr masked;
     masked.s_addr = HostToNetwork32(host_order_ip & mask);
     return IPAddress(masked);
   } else if (ip.family() == AF_INET6) {
     if (length > 127) {
       return ip;
     }
     if (length == 0) {
       return IPAddress(in6addr_any);
     }
     in6_addr v6addr = ip.ipv6_address();
     int position = length / 32;
     int inner_length = 32 - (length - (position * 32));
     // Note: 64bit mask constant needed to allow possible 32-bit left shift.
-    uint32 inner_mask = 0xFFFFFFFFLL  << inner_length;
-    uint32* v6_as_ints =
-        reinterpret_cast<uint32*>(&v6addr.s6_addr);
+    uint32_t inner_mask = 0xFFFFFFFFLL << inner_length;
+    uint32_t* v6_as_ints = reinterpret_cast<uint32_t*>(&v6addr.s6_addr);
     for (int i = 0; i < 4; ++i) {
       if (i == position) {
-        uint32 host_order_inner = NetworkToHost32(v6_as_ints[i]);
+        uint32_t host_order_inner = NetworkToHost32(v6_as_ints[i]);
         v6_as_ints[i] = HostToNetwork32(host_order_inner & inner_mask);
       } else if (i > position) {
         v6_as_ints[i] = 0;
       }
     }
     return IPAddress(v6addr);
   }
   return IPAddress();
 }
 
 int CountIPMaskBits(IPAddress mask) {
-  uint32 word_to_count = 0;
+  uint32_t word_to_count = 0;
   int bits = 0;
   switch (mask.family()) {
     case AF_INET: {
       word_to_count = NetworkToHost32(mask.ipv4_address().s_addr);
       break;
     }
     case AF_INET6: {
       in6_addr v6addr = mask.ipv6_address();
-      const uint32* v6_as_ints =
-          reinterpret_cast<const uint32*>(&v6addr.s6_addr);
+      const uint32_t* v6_as_ints =
+          reinterpret_cast<const uint32_t*>(&v6addr.s6_addr);
       int i = 0;
       for (; i < 4; ++i) {
         if (v6_as_ints[i] != 0xFFFFFFFF) {
           break;
         }
       }
       if (i < 4) {
         word_to_count = NetworkToHost32(v6_as_ints[i]);
       }
       bits = (i * 32);
       break;
     }
     default: {
       return 0;
     }
   }
   if (word_to_count == 0) {
     return bits;
   }
 
   // Public domain bit-twiddling hack from:
   // http://graphics.stanford.edu/~seander/bithacks.html
   // Counts the trailing 0s in the word.
   unsigned int zeroes = 32;
-  word_to_count &= -static_cast<int32>(word_to_count);
+  word_to_count &= -static_cast<int32_t>(word_to_count);
   if (word_to_count) zeroes--;
   if (word_to_count & 0x0000FFFF) zeroes -= 16;
   if (word_to_count & 0x00FF00FF) zeroes -= 8;
   if (word_to_count & 0x0F0F0F0F) zeroes -= 4;
   if (word_to_count & 0x33333333) zeroes -= 2;
   if (word_to_count & 0x55555555) zeroes -= 1;
 
   return bits + (32 - zeroes);
 }
 
@@ skipping 79 matching lines @@
 IPAddress GetLoopbackIP(int family) {
   if (family == AF_INET) {
     return rtc::IPAddress(INADDR_LOOPBACK);
   }
   if (family == AF_INET6) {
     return rtc::IPAddress(in6addr_loopback);
   }
   return rtc::IPAddress();
 }
 }  // Namespace rtc