/src/FreeRDP/winpr/include/winpr/endian.h

Source (jump to first uncovered line)
/*
 * WinPR: Windows Portable Runtime
 * Endianness Macros
 *
 * Copyright 2013 Marc-Andre Moreau <marcandre.moreau@gmail.com>
 * Copyright 2024 Armin Novak <anovak@thincast.com>
 * Copyright 2024 Thincast Technologies GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef WINPR_ENDIAN_H
#define WINPR_ENDIAN_H

#include <winpr/winpr.h>
#include <winpr/wtypes.h>
#include <winpr/platform.h>
#include <winpr/assert.h>
#include <winpr/cast.h>

#define WINPR_ENDIAN_CAST(t, val) WINPR_CXX_COMPAT_CAST(t, val)

#ifdef __cplusplus
extern "C"
{
#endif

  static INLINE UINT8 winpr_Data_Get_UINT8(const void* d)
  {
    WINPR_ASSERT(d);
    const UINT8* ptr = WINPR_ENDIAN_CAST(const UINT8*, d);
    return *ptr;
  }

  static INLINE INT8 winpr_Data_Get_INT8(const void* d)
  {
    WINPR_ASSERT(d);
    const INT8* ptr = WINPR_ENDIAN_CAST(const INT8*, d);
    return *ptr;
  }

  static INLINE UINT16 winpr_Data_Get_UINT16_NE(const void* d)
  {
    const UINT16* ptr = WINPR_ENDIAN_CAST(const UINT16*, d);
    return *ptr;
  }

  static INLINE UINT16 winpr_Data_Get_UINT16(const void* d)
  {
    WINPR_ASSERT(d);
    const UINT8* ptr = WINPR_ENDIAN_CAST(const UINT8*, d);
    const size_t typesize = sizeof(UINT16);
    UINT16 v = 0;
    for (size_t x = 0; x < typesize; x++)
    {
      v <<= 8;
      v |= ptr[typesize - x - 1];
    }
    return v;
  }

  static INLINE UINT16 winpr_Data_Get_UINT16_BE(const void* d)
  {
    WINPR_ASSERT(d);
    const UINT8* ptr = WINPR_ENDIAN_CAST(const UINT8*, d);
    const size_t typesize = sizeof(UINT16);
    UINT16 v = 0;
    for (size_t x = 0; x < typesize; x++)
    {
      v <<= 8;
      v |= ptr[x];
    }
    return v;
  }

  static INLINE INT16 winpr_Data_Get_INT16_NE(const void* d)
  {
    WINPR_ASSERT(d);
    const INT16* ptr = WINPR_ENDIAN_CAST(const INT16*, d);
    return *ptr;
  }

  static INLINE INT16 winpr_Data_Get_INT16(const void* d)
  {
    const UINT16 u16 = winpr_Data_Get_UINT16(d);
    return WINPR_ENDIAN_CAST(INT16, u16);
  }

  static INLINE INT16 winpr_Data_Get_INT16_BE(const void* d)
  {
    const UINT16 u16 = winpr_Data_Get_UINT16_BE(d);
    return WINPR_ENDIAN_CAST(INT16, u16);
  }

  static INLINE UINT32 winpr_Data_Get_UINT32_NE(const void* d)
  {
    WINPR_ASSERT(d);
    const UINT32* ptr = WINPR_ENDIAN_CAST(const UINT32*, d);
    return *ptr;
  }

  static INLINE UINT32 winpr_Data_Get_UINT32(const void* d)
  {
    WINPR_ASSERT(d);
    const UINT8* ptr = WINPR_ENDIAN_CAST(const UINT8*, d);
    const size_t typesize = sizeof(UINT32);
    UINT32 v = 0;
    for (size_t x = 0; x < typesize; x++)
    {
      v <<= 8;
      v |= ptr[typesize - x - 1];
    }
    return v;
  }

  static INLINE UINT32 winpr_Data_Get_UINT32_BE(const void* d)
  {
    WINPR_ASSERT(d);
    const UINT8* ptr = WINPR_ENDIAN_CAST(const UINT8*, d);
    const size_t typesize = sizeof(UINT32);
    UINT32 v = 0;
    for (size_t x = 0; x < typesize; x++)
    {
      v <<= 8;
      v |= ptr[x];
    }
    return v;
  }

  static INLINE INT32 winpr_Data_Get_INT32_NE(const void* d)
  {
    WINPR_ASSERT(d);
    const INT32* ptr = WINPR_ENDIAN_CAST(const INT32*, d);
    return *ptr;
  }

  static INLINE INT32 winpr_Data_Get_INT32(const void* d)
  {
    const UINT32 u32 = winpr_Data_Get_UINT32(d);
    return WINPR_ENDIAN_CAST(INT32, u32);
  }

  static INLINE INT32 winpr_Data_Get_INT32_BE(const void* d)
  {
    const UINT32 u32 = winpr_Data_Get_UINT32_BE(d);
    return WINPR_ENDIAN_CAST(INT32, u32);
  }

  static INLINE UINT64 winpr_Data_Get_UINT64_NE(const void* d)
  {
    WINPR_ASSERT(d);
    const UINT64* ptr = WINPR_ENDIAN_CAST(const UINT64*, d);
    return *ptr;
  }

  static INLINE UINT64 winpr_Data_Get_UINT64(const void* d)
  {
    WINPR_ASSERT(d);
    const UINT8* ptr = WINPR_ENDIAN_CAST(const UINT8*, d);
    const size_t typesize = sizeof(UINT64);
    UINT64 v = 0;
    for (size_t x = 0; x < typesize; x++)
    {
      v <<= 8;
      v |= ptr[typesize - x - 1];
    }
    return v;
  }

  static INLINE UINT64 winpr_Data_Get_UINT64_BE(const void* d)
  {
    WINPR_ASSERT(d);
    const UINT8* ptr = WINPR_ENDIAN_CAST(const UINT8*, d);
    const size_t typesize = sizeof(UINT64);
    UINT64 v = 0;
    for (size_t x = 0; x < typesize; x++)
    {
      v <<= 8;
      v |= ptr[x];
    }
    return v;
  }

  static INLINE INT64 winpr_Data_Get_INT64_NE(const void* d)
  {
    WINPR_ASSERT(d);
    const INT64* b = WINPR_ENDIAN_CAST(const INT64*, d);
    return *b;
  }

  static INLINE INT64 winpr_Data_Get_INT64(const void* d)
  {
    const UINT64 u64 = winpr_Data_Get_UINT64(d);
    return WINPR_ENDIAN_CAST(INT64, u64);
  }

  static INLINE INT64 winpr_Data_Get_INT64_BE(const void* d)
  {
    const UINT64 u64 = winpr_Data_Get_UINT64_BE(d);
    return WINPR_ENDIAN_CAST(INT64, u64);
  }

  static INLINE void winpr_Data_Write_UINT8_NE(void* d, UINT8 v)
  {
    WINPR_ASSERT(d);
    BYTE* b = WINPR_ENDIAN_CAST(BYTE*, d);
    *b = v;
  }

  static INLINE void winpr_Data_Write_UINT8(void* d, UINT8 v)
  {
    WINPR_ASSERT(d);
    BYTE* b = WINPR_ENDIAN_CAST(BYTE*, d);
    *b = v;
  }

  static INLINE void winpr_Data_Write_UINT16_NE(void* d, UINT16 v)
  {
    WINPR_ASSERT(d);
    UINT16* b = WINPR_ENDIAN_CAST(UINT16*, d);
    *b = v;
  }

  static INLINE void winpr_Data_Write_UINT16(void* d, UINT16 v)
  {
    WINPR_ASSERT(d);
    BYTE* b = WINPR_ENDIAN_CAST(BYTE*, d);
    b[0] = v & 0xFF;
    b[1] = (v >> 8) & 0xFF;
  }

  static INLINE void winpr_Data_Write_UINT16_BE(void* d, UINT16 v)
  {
    WINPR_ASSERT(d);
    BYTE* b = WINPR_ENDIAN_CAST(BYTE*, d);
    b[1] = v & 0xFF;
    b[0] = (v >> 8) & 0xFF;
  }

  static INLINE void winpr_Data_Write_UINT32_NE(void* d, UINT32 v)
  {
    WINPR_ASSERT(d);
    UINT32* b = WINPR_ENDIAN_CAST(UINT32*, d);
    *b = v;
  }

  static INLINE void winpr_Data_Write_UINT32(void* d, UINT32 v)
  {
    WINPR_ASSERT(d);
    BYTE* b = WINPR_ENDIAN_CAST(BYTE*, d);
    winpr_Data_Write_UINT16(b, v & 0xFFFF);
    winpr_Data_Write_UINT16(b + 2, (v >> 16) & 0xFFFF);
  }

  static INLINE void winpr_Data_Write_UINT32_BE(void* d, UINT32 v)
  {
    WINPR_ASSERT(d);
    BYTE* b = WINPR_ENDIAN_CAST(BYTE*, d);
    winpr_Data_Write_UINT16_BE(b, (v >> 16) & 0xFFFF);
    winpr_Data_Write_UINT16_BE(b + 2, v & 0xFFFF);
  }

  static INLINE void winpr_Data_Write_UINT64_NE(void* d, UINT64 v)
  {
    WINPR_ASSERT(d);
    UINT64* b = WINPR_ENDIAN_CAST(UINT64*, d);
    *b = v;
  }

  static INLINE void winpr_Data_Write_UINT64(void* d, UINT64 v)
  {
    WINPR_ASSERT(d);
    BYTE* b = WINPR_ENDIAN_CAST(BYTE*, d);
    winpr_Data_Write_UINT32(b, v & 0xFFFFFFFF);
    winpr_Data_Write_UINT32(b + 4, (v >> 32) & 0xFFFFFFFF);
  }

  static INLINE void winpr_Data_Write_UINT64_BE(void* d, UINT64 v)
  {
    WINPR_ASSERT(d);
    BYTE* b = WINPR_ENDIAN_CAST(BYTE*, d);
    winpr_Data_Write_UINT32_BE(b, (v >> 32) & 0xFFFFFFFF);
    winpr_Data_Write_UINT32_BE(b + 4, v & 0xFFFFFFFF);
  }

  static INLINE void winpr_Data_Write_INT8_NE(void* d, INT8 v)
  {
    WINPR_ASSERT(d);
    INT8* b = WINPR_ENDIAN_CAST(INT8*, d);
    *b = v;
  }

  static INLINE void winpr_Data_Write_INT8(void* d, INT8 v)
  {
    WINPR_ASSERT(d);
    INT8* b = WINPR_ENDIAN_CAST(INT8*, d);
    *b = v;
  }

  static INLINE void winpr_Data_Write_INT16_NE(void* d, INT16 v)
  {
    WINPR_ASSERT(d);
    INT16* b = WINPR_ENDIAN_CAST(INT16*, d);
    *b = v;
  }

  static INLINE void winpr_Data_Write_INT16(void* d, INT16 v)
  {
    WINPR_ASSERT(d);
    BYTE* b = WINPR_ENDIAN_CAST(BYTE*, d);
    b[0] = v & 0xFF;
    b[1] = (v >> 8) & 0xFF;
  }

  static INLINE void winpr_Data_Write_INT16_BE(void* d, INT16 v)
  {
    WINPR_ASSERT(d);
    BYTE* b = WINPR_ENDIAN_CAST(BYTE*, d);
    b[1] = v & 0xFF;
    b[0] = (v >> 8) & 0xFF;
  }

  static INLINE void winpr_Data_Write_INT32_NE(void* d, INT32 v)
  {
    WINPR_ASSERT(d);
    INT32* pu = WINPR_ENDIAN_CAST(INT32*, d);
    *pu = v;
  }

  static INLINE void winpr_Data_Write_INT32(void* d, INT32 v)
  {
    WINPR_ASSERT(d);
    BYTE* b = WINPR_ENDIAN_CAST(BYTE*, d);
    winpr_Data_Write_UINT16(b, v & 0xFFFF);
    winpr_Data_Write_UINT16(b + 2, (v >> 16) & 0xFFFF);
  }

  static INLINE void winpr_Data_Write_INT32_BE(void* d, INT32 v)
  {
    WINPR_ASSERT(d);
    BYTE* b = WINPR_ENDIAN_CAST(BYTE*, d);
    winpr_Data_Write_UINT16_BE(b, (v >> 16) & 0xFFFF);
    winpr_Data_Write_UINT16_BE(b + 2, v & 0xFFFF);
  }

  static INLINE void winpr_Data_Write_INT64_NE(void* d, INT64 v)
  {
    WINPR_ASSERT(d);
    INT64* pu = WINPR_ENDIAN_CAST(INT64*, d);
    *pu = v;
  }

  static INLINE void winpr_Data_Write_INT64(void* d, INT64 v)
  {
    WINPR_ASSERT(d);
    BYTE* b = WINPR_ENDIAN_CAST(BYTE*, d);
    winpr_Data_Write_UINT32(b, v & 0xFFFFFFFF);
    winpr_Data_Write_UINT32(b + 4, (v >> 32) & 0xFFFFFFFF);
  }

  static INLINE void winpr_Data_Write_INT64_BE(void* d, INT64 v)
  {
    WINPR_ASSERT(d);
    BYTE* b = WINPR_ENDIAN_CAST(BYTE*, d);
    winpr_Data_Write_UINT32_BE(b, (v >> 32) & 0xFFFFFFFF);
    winpr_Data_Write_UINT32_BE(b + 4, v & 0xFFFFFFFF);
  }

#if defined(WINPR_DEPRECATED)
#define Data_Read_UINT8_NE(_d, _v) _v = winpr_Data_Get_UINT8(_d)

#define Data_Read_UINT8(_d, _v) _v = winpr_Data_Get_UINT8(_d)

#define Data_Read_UINT16_NE(_d, _v) _v = winpr_Data_Get_UINT16_NE(_d)

#define Data_Read_UINT16(_d, _v) _v = winpr_Data_Get_UINT16(_d)

#define Data_Read_UINT16_BE(_d, _v) _v = winpr_Data_Get_UINT16_BE(_d)

#define Data_Read_UINT32_NE(_d, _v) _v = winpr_Data_Get_UINT32_NE(_d)

#define Data_Read_UINT32(_d, _v) _v = winpr_Data_Get_UINT32(_d)

#define Data_Read_UINT32_BE(_d, _v) _v = winpr_Data_Get_UINT32_BE(_d)

#define Data_Read_UINT64_NE(_d, _v) _v = winpr_Data_Get_UINT64_NE(_d)

#define Data_Read_UINT64(_d, _v) _v = winpr_Data_Get_UINT64(_d)

#define Data_Read_UINT64_BE(_d, _v) _v = winpr_Data_Get_UINT64_BE(_d)

#define Data_Write_UINT8_NE(_d, _v) winpr_Data_Write_UINT8_NE(_d, _v)

#define Data_Write_UINT8(_d, _v) winpr_Data_Write_UINT8(_d, _v)

#define Data_Write_UINT16_NE(_d, _v) winpr_Data_Write_UINT16_NE(_d, _v)
#define Data_Write_UINT16(_d, _v) winpr_Data_Write_UINT16(_d, _v)

#define Data_Write_UINT16_BE(_d, _v) winpr_Data_Write_UINT16_BE(_d, _v)

#define Data_Write_UINT32_NE(_d, _v) winpr_Data_Write_UINT32_NE(_d, _v)

#define Data_Write_UINT32(_d, _v) winpr_Data_Write_UINT32(_d, _v)

#define Data_Write_UINT32_BE(_d, _v) winpr_Data_Write_UINT32_BE(_d, _v)

#define Data_Write_UINT64_NE(_d, _v) winpr_Data_Write_UINT64_NE(_d, _v)

#define Data_Write_UINT64(_d, _v) winpr_Data_Write_UINT64(_d, _v)

#define Data_Write_UINT64_BE(_d, _v) winpr_Data_Write_UINT64_BE(_d, _v)
#endif

#ifdef __cplusplus
}
#endif

#endif /* WINPR_ENDIAN_H */

Coverage Report

Created: 2025-08-03 07:05

Line	Count	Source (jump to first uncovered line)
1		/*
2		* WinPR: Windows Portable Runtime
3		* Endianness Macros
4		*
5		* Copyright 2013 Marc-Andre Moreau <marcandre.moreau@gmail.com>
6		* Copyright 2024 Armin Novak <anovak@thincast.com>
7		* Copyright 2024 Thincast Technologies GmbH
8		*
9		* Licensed under the Apache License, Version 2.0 (the "License");
10		* you may not use this file except in compliance with the License.
11		* You may obtain a copy of the License at
12		*
13		* http://www.apache.org/licenses/LICENSE-2.0
14		*
15		* Unless required by applicable law or agreed to in writing, software
16		* distributed under the License is distributed on an "AS IS" BASIS,
17		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18		* See the License for the specific language governing permissions and
19		* limitations under the License.
20		*/
21
22		#ifndef WINPR_ENDIAN_H
23		#define WINPR_ENDIAN_H
24
25		#include <winpr/winpr.h>
26		#include <winpr/wtypes.h>
27		#include <winpr/platform.h>
28		#include <winpr/assert.h>
29		#include <winpr/cast.h>
30
31	0	#define WINPR_ENDIAN_CAST(t, val) WINPR_CXX_COMPAT_CAST(t, val)
32
33		#ifdef __cplusplus
34		extern "C"
35		{
36		#endif
37
38		static INLINE UINT8 winpr_Data_Get_UINT8(const void* d)
39	0	{