<sys/endian.h>: Use basic integer types.
authorSascha Wildner <saw@online.de>
Thu, 20 Sep 2018 08:22:23 +0000 (10:22 +0200)
committerSascha Wildner <saw@online.de>
Thu, 20 Sep 2018 08:22:23 +0000 (10:22 +0200)
We might at some point stop including <sys/types.h> too, in favor of
<machine/stdint.h>, but I first need to test which ports assume that
<sys/types.h> comes in with <sys/endian.h>.

sys/sys/endian.h

index 361bc3f..d175bd8 100644 (file)
 #define        htobe16(x)      bswap16((x))
 #define        htobe32(x)      bswap32((x))
 #define        htobe64(x)      bswap64((x))
-#define        htole16(x)      ((uint16_t)(x))
-#define        htole32(x)      ((uint32_t)(x))
-#define        htole64(x)      ((uint64_t)(x))
+#define        htole16(x)      ((__uint16_t)(x))
+#define        htole32(x)      ((__uint32_t)(x))
+#define        htole64(x)      ((__uint64_t)(x))
 
 #define        be16toh(x)      bswap16((x))
 #define        be32toh(x)      bswap32((x))
 #define        be64toh(x)      bswap64((x))
-#define        le16toh(x)      ((uint16_t)(x))
-#define        le32toh(x)      ((uint32_t)(x))
-#define        le64toh(x)      ((uint64_t)(x))
+#define        le16toh(x)      ((__uint16_t)(x))
+#define        le32toh(x)      ((__uint32_t)(x))
+#define        le64toh(x)      ((__uint64_t)(x))
 #else /* _BYTE_ORDER != _LITTLE_ENDIAN */
-#define        htobe16(x)      ((uint16_t)(x))
-#define        htobe32(x)      ((uint32_t)(x))
-#define        htobe64(x)      ((uint64_t)(x))
+#define        htobe16(x)      ((__uint16_t)(x))
+#define        htobe32(x)      ((__uint32_t)(x))
+#define        htobe64(x)      ((__uint64_t)(x))
 #define        htole16(x)      bswap16((x))
 #define        htole32(x)      bswap32((x))
 #define        htole64(x)      bswap64((x))
 
-#define        be16toh(x)      ((uint16_t)(x))
-#define        be32toh(x)      ((uint32_t)(x))
-#define        be64toh(x)      ((uint64_t)(x))
+#define        be16toh(x)      ((__uint16_t)(x))
+#define        be32toh(x)      ((__uint32_t)(x))
+#define        be64toh(x)      ((__uint64_t)(x))
 #define        le16toh(x)      bswap16((x))
 #define        le32toh(x)      bswap32((x))
 #define        le64toh(x)      bswap64((x))
 
 /* Alignment-agnostic encode/decode bytestream to/from little/big endian. */
 
-static __inline uint16_t
+static __inline __uint16_t
 be16dec(const void *pp)
 {
-       const uint8_t *p = (const uint8_t *)pp;
+       const __uint8_t *p = (const __uint8_t *)pp;
 
        return ((p[0] << 8) | p[1]);
 }
 
-static __inline uint32_t
+static __inline __uint32_t
 be32dec(const void *pp)
 {
-       const uint8_t *p = (const uint8_t *)pp;
+       const __uint8_t *p = (const __uint8_t *)pp;
 
        return ((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]);
 }
 
-static __inline uint64_t
+static __inline __uint64_t
 be64dec(const void *pp)
 {
-       const uint8_t *p = (const uint8_t *)pp;
+       const __uint8_t *p = (const __uint8_t *)pp;
 
-       return (((uint64_t)be32dec(p) << 32) | be32dec(p + 4));
+       return (((__uint64_t)be32dec(p) << 32) | be32dec(p + 4));
 }
 
-static __inline uint16_t
+static __inline __uint16_t
 le16dec(const void *pp)
 {
-       const uint8_t *p = (const uint8_t *)pp;
+       const __uint8_t *p = (const __uint8_t *)pp;
 
        return ((p[1] << 8) | p[0]);
 }
 
-static __inline uint32_t
+static __inline __uint32_t
 le32dec(const void *pp)
 {
-       const uint8_t *p = (const uint8_t *)pp;
+       const __uint8_t *p = (const __uint8_t *)pp;
 
        return ((p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0]);
 }
 
-static __inline uint64_t
+static __inline __uint64_t
 le64dec(const void *pp)
 {
-       const uint8_t *p = (const uint8_t *)pp;
+       const __uint8_t *p = (const __uint8_t *)pp;
 
-       return (((uint64_t)le32dec(p + 4) << 32) | le32dec(p));
+       return (((__uint64_t)le32dec(p + 4) << 32) | le32dec(p));
 }
 
 static __inline void
-be16enc(void *pp, uint16_t u)
+be16enc(void *pp, __uint16_t u)
 {
-       uint8_t *p = (uint8_t *)pp;
+       __uint8_t *p = (__uint8_t *)pp;
 
        p[0] = (u >> 8) & 0xff;
        p[1] = u & 0xff;
 }
 
 static __inline void
-be32enc(void *pp, uint32_t u)
+be32enc(void *pp, __uint32_t u)
 {
-       uint8_t *p = (uint8_t *)pp;
+       __uint8_t *p = (__uint8_t *)pp;
 
        p[0] = (u >> 24) & 0xff;
        p[1] = (u >> 16) & 0xff;
@@ -148,27 +148,27 @@ be32enc(void *pp, uint32_t u)
 }
 
 static __inline void
-be64enc(void *pp, uint64_t u)
+be64enc(void *pp, __uint64_t u)
 {
-       uint8_t *p = (uint8_t *)pp;
+       __uint8_t *p = (__uint8_t *)pp;
 
        be32enc(p, u >> 32);
        be32enc(p + 4, u & 0xffffffff);
 }
 
 static __inline void
-le16enc(void *pp, uint16_t u)
+le16enc(void *pp, __uint16_t u)
 {
-       uint8_t *p = (uint8_t *)pp;
+       __uint8_t *p = (__uint8_t *)pp;
 
        p[0] = u & 0xff;
        p[1] = (u >> 8) & 0xff;
 }
 
 static __inline void
-le32enc(void *pp, uint32_t u)
+le32enc(void *pp, __uint32_t u)
 {
-       uint8_t *p = (uint8_t *)pp;
+       __uint8_t *p = (__uint8_t *)pp;
 
        p[0] = u & 0xff;
        p[1] = (u >> 8) & 0xff;
@@ -177,9 +177,9 @@ le32enc(void *pp, uint32_t u)
 }
 
 static __inline void
-le64enc(void *pp, uint64_t u)
+le64enc(void *pp, __uint64_t u)
 {
-       uint8_t *p = (uint8_t *)pp;
+       __uint8_t *p = (__uint8_t *)pp;
 
        le32enc(p, u & 0xffffffff);
        le32enc(p + 4, u >> 32);