2017-01-25 19:49:09 +01:00
//---------------------------------------------------------------------------------------------------------------------------------
2017-01-27 22:42:10 +01:00
// File: xplat_intsafe.h
2017-01-25 19:49:09 +01:00
//
// Contents: This module defines helper functions to prevent
// integer overflow bugs.
//
2017-01-27 02:17:12 +01:00
// Microsoft Drivers 4.1 for PHP for SQL Server
2017-01-25 19:49:09 +01:00
// Copyright(c) Microsoft Corporation
// All rights reserved.
// MIT License
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files(the ""Software""),
// to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and / or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions :
// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//---------------------------------------------------------------------------------------------------------------------------------
# ifndef XPLAT_INTSAFE_H
# define XPLAT_INTSAFE_H
# if (_MSC_VER > 1000)
# pragma once
# endif
# if !defined(_W64)
# if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && (_MSC_VER >= 1300)
# define _W64 __w64
# else
# define _W64
# endif
# endif
2017-01-27 22:42:10 +01:00
# include "sal_def.h"
2017-01-25 19:49:09 +01:00
# include <limits.h>
//
// typedefs
//
typedef char CHAR ;
typedef signed char INT8 ;
typedef unsigned char UCHAR ;
typedef unsigned char UINT8 ;
typedef unsigned char BYTE ;
typedef short SHORT ;
typedef signed short INT16 ;
typedef unsigned short USHORT ;
typedef unsigned short UINT16 ;
typedef unsigned short WORD ;
typedef int INT ;
typedef signed int INT32 ;
typedef unsigned int UINT ;
typedef unsigned int UINT32 ;
typedef windowsLong_t LONG ;
typedef windowsULong_t DWORD ;
typedef windowsLongLong_t LONGLONG ;
typedef windowsLongLong_t LONG64 ;
typedef windowsLongLong_t INT64 ;
typedef windowsULongLong_t ULONGLONG ;
typedef windowsULongLong_t DWORDLONG ;
typedef windowsULongLong_t ULONG64 ;
typedef windowsULongLong_t DWORD64 ;
typedef windowsULongLong_t UINT64 ;
# if (__midl > 501)
typedef [ public ] __int3264 INT_PTR ;
typedef [ public ] unsigned __int3264 UINT_PTR ;
typedef [ public ] __int3264 LONG_PTR ;
typedef [ public ] unsigned __int3264 ULONG_PTR ;
# else
# ifdef _WIN64
typedef __int64 INT_PTR , * PINT_PTR ;
typedef unsigned __int64 UINT_PTR , * PUINT_PTR ;
typedef __int64 LONG_PTR , * PLONG_PTR ;
typedef unsigned __int64 ULONG_PTR , * PULONG_PTR ;
# else
typedef _W64 int INT_PTR , * PINT_PTR ;
typedef _W64 unsigned int UINT_PTR , * PUINT_PTR ;
typedef _W64 windowsLong_t LONG_PTR , * PLONG_PTR ;
typedef _W64 windowsULong_t ULONG_PTR , * PULONG_PTR ;
# endif // WIN64
# endif // (__midl > 501)
typedef ULONG_PTR DWORD_PTR ;
typedef LONG_PTR SSIZE_T ;
typedef ULONG_PTR SIZE_T ;
# if defined(_AMD64_)
# ifdef __cplusplus
extern " C " {
# endif
# define UnsignedMultiply128 _umul128
ULONG64
UnsignedMultiply128 (
__inn ULONG64 Multiplier ,
__inn ULONG64 Multiplicand ,
__outt __deref_out_range ( = = , Multiplier * Multiplicand ) ULONG64 * HighProduct
) ;
# pragma intrinsic(_umul128)
# ifdef __cplusplus
}
# endif
# endif // _AMD64_
typedef __success ( return > = 0 ) windowsLong_t HRESULT ;
# define SUCCEEDED(hr) (((HRESULT)(hr)) >= 0)
# define FAILED(hr) (((HRESULT)(hr)) < 0)
# define S_OK ((HRESULT)0L)
# define INTSAFE_E_ARITHMETIC_OVERFLOW ((HRESULT)0x80070216L) // 0x216 = 534 = ERROR_ARITHMETIC_OVERFLOW
# ifndef SORTPP_PASS
// compiletime asserts (failure results in error C2118: negative subscript)
# define C_ASSERT(e) typedef char __C_ASSERT__[(e)?1:-1]
# else
# define C_ASSERT(e)
# endif
//
// UInt32x32To64 macro
//
# define UInt32x32To64(a, b) ((windowsULongLong_t)(((windowsULongLong_t)(a)) * ((windowsULong_t)(b))))
//
// Min/Max type values
//
//#define INT8_MIN (-127 - 1)
# define SHORT_MIN (-32768)
//#define INT16_MIN (-32767 - 1)
//#define INT_MIN (-2147483647 - 1)
//#define INT32_MIN (-2147483647l - 1)
//#define LONG_MIN (-2147483647L - 1)
# define LONGLONG_MIN (-9223372036854775807ll - 1)
# define LONG64_MIN (-9223372036854775807ll - 1)
//#define INT64_MIN (-9223372036854775807ll - 1)
# define INT128_MIN (-170141183460469231731687303715884105727i128 - 1)
# ifdef _WIN64
# define INT_PTR_MIN (-9223372036854775807ll - 1)
# define LONG_PTR_MIN (-9223372036854775807ll - 1)
# define PTRDIFF_T_MIN (-9223372036854775807ll - 1)
# define SSIZE_T_MIN (-9223372036854775807ll - 1)
# else
# define INT_PTR_MIN (-2147483647 - 1)
# define LONG_PTR_MIN (-2147483647L - 1)
# define PTRDIFF_T_MIN (-2147483647 - 1)
# define SSIZE_T_MIN (-2147483647L - 1)
# endif
//#define INT8_MAX 127
//#define UINT8_MAX 0xff
# define BYTE_MAX 0xff
# define SHORT_MAX 32767
//#define INT16_MAX 32767
# define USHORT_MAX 0xffff
//#define UINT16_MAX 0xffff
# define WORD_MAX 0xffff
//#define INT_MAX 2147483647
//#define INT32_MAX 2147483647l
//#define UINT_MAX 0xffffffff
//#define UINT32_MAX 0xfffffffful
//#define LONG_MAX 2147483647L
//#define ULONG_MAX 0xffffffffUL
# define DWORD_MAX 0xffffffffUL
# define LONGLONG_MAX 9223372036854775807ll
# define LONG64_MAX 9223372036854775807ll
//#define INT64_MAX 9223372036854775807ll
# define ULONGLONG_MAX 0xffffffffffffffffull
# define DWORDLONG_MAX 0xffffffffffffffffull
# define ULONG64_MAX 0xffffffffffffffffull
# define DWORD64_MAX 0xffffffffffffffffull
//#define UINT64_MAX 0xffffffffffffffffull
# define INT128_MAX 170141183460469231731687303715884105727i128
# define UINT128_MAX 0xffffffffffffffffffffffffffffffffui128
# ifndef _I64_MIN
# define _I64_MIN INT64_MIN
# define _I64_MAX INT64_MAX
# define _UI64_MIN UINT64_MIN
# define _UI64_MAX UINT64_MAX
# endif
# undef SIZE_T_MAX
# ifdef _WIN64
# define INT_PTR_MAX 9223372036854775807ll
# define UINT_PTR_MAX 0xffffffffffffffffull
# define LONG_PTR_MAX 9223372036854775807ll
# define ULONG_PTR_MAX 0xffffffffffffffffull
# define DWORD_PTR_MAX 0xffffffffffffffffull
# define PTRDIFF_T_MAX 9223372036854775807ll
# define SIZE_T_MAX 0xffffffffffffffffull
# define SSIZE_T_MAX 9223372036854775807ll
# define _SIZE_T_MAX 0xffffffffffffffffull
# else
# define INT_PTR_MAX 2147483647
# define UINT_PTR_MAX 0xffffffff
# define LONG_PTR_MAX 2147483647L
# define ULONG_PTR_MAX 0xffffffffUL
# define DWORD_PTR_MAX 0xffffffffUL
# define PTRDIFF_T_MAX 2147483647
# define SIZE_T_MAX 0xffffffff
# define SSIZE_T_MAX 2147483647L
# define _SIZE_T_MAX 0xffffffffUL
# endif
//
// It is common for -1 to be used as an error value
//
# define INT8_ERROR (-1)
# define UINT8_ERROR 0xff
# define BYTE_ERROR 0xff
# define SHORT_ERROR (-1)
# define INT16_ERROR (-1)
# define USHORT_ERROR 0xffff
# define UINT16_ERROR 0xffff
# define WORD_ERROR 0xffff
# define INT_ERROR (-1)
# define INT32_ERROR (-1l)
# define UINT_ERROR 0xffffffff
# define UINT32_ERROR 0xfffffffful
# define LONG_ERROR (-1L)
# define ULONG_ERROR 0xffffffffUL
# define DWORD_ERROR 0xffffffffUL
# define LONGLONG_ERROR (-1ll)
# define LONG64_ERROR (-1ll)
# define INT64_ERROR (-1ll)
# define ULONGLONG_ERROR 0xffffffffffffffffull
# define DWORDLONG_ERROR 0xffffffffffffffffull
# define ULONG64_ERROR 0xffffffffffffffffull
# define UINT64_ERROR 0xffffffffffffffffull
# ifdef _WIN64
# define INT_PTR_ERROR (-1ll)
# define UINT_PTR_ERROR 0xffffffffffffffffull
# define LONG_PTR_ERROR (-1ll)
# define ULONG_PTR_ERROR 0xffffffffffffffffull
# define DWORD_PTR_ERROR 0xffffffffffffffffull
# define PTRDIFF_T_ERROR (-1ll)
# define SIZE_T_ERROR 0xffffffffffffffffull
# define SSIZE_T_ERROR (-1ll)
# define _SIZE_T_ERROR 0xffffffffffffffffull
# else
# define INT_PTR_ERROR (-1)
# define UINT_PTR_ERROR 0xffffffff
# define LONG_PTR_ERROR (-1L)
# define ULONG_PTR_ERROR 0xffffffffUL
# define DWORD_PTR_ERROR 0xffffffffUL
# define PTRDIFF_T_ERROR (-1)
# define SIZE_T_ERROR 0xffffffff
# define SSIZE_T_ERROR (-1L)
# define _SIZE_T_ERROR 0xffffffffUL
# endif
//
// We make some assumptions about the sizes of various types. Let's be
// explicit about those assumptions and check them.
//
C_ASSERT ( sizeof ( USHORT ) = = 2 ) ;
C_ASSERT ( sizeof ( INT ) = = 4 ) ;
C_ASSERT ( sizeof ( UINT ) = = 4 ) ;
C_ASSERT ( sizeof ( LONG ) = = 4 ) ;
C_ASSERT ( sizeof ( ULONG ) = = 8 ) ;
C_ASSERT ( sizeof ( UINT_PTR ) = = sizeof ( ULONG_PTR ) ) ;
//=============================================================================
// Conversion functions
//
// There are three reasons for having conversion functions:
//
// 1. We are converting from a signed type to an unsigned type of the same
// size, or vice-versa.
//
// Since we only have unsigned math functions, this allows people to convert
// to unsigned, do the math, and then convert back to signed.
//
// 2. We are converting to a smaller type, and we could therefore possibly
// overflow.
//
// 3. We are converting to a bigger type, and we are signed and the type we are
// converting to is unsigned.
//
//=============================================================================
//
// INT8 -> UCHAR conversion
//
__inline
HRESULT
Int8ToUChar (
__inn INT8 i8Operand ,
__outt __deref_out_range ( = = , i8Operand ) UCHAR * pch )
{
HRESULT hr ;
if ( i8Operand > = 0 )
{
* pch = ( UCHAR ) i8Operand ;
hr = S_OK ;
}
else
{
* pch = ' \0 ' ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT8 -> UINT8 conversion
//
__inline
HRESULT
Int8ToUInt8 (
__inn INT8 i8Operand ,
__outt __deref_out_range ( = = , i8Operand ) UINT8 * pu8Result )
{
HRESULT hr ;
if ( i8Operand > = 0 )
{
* pu8Result = ( UINT8 ) i8Operand ;
hr = S_OK ;
}
else
{
* pu8Result = UINT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT8 -> BYTE conversion
//
# define Int8ToByte Int8ToUInt8
//
// INT8 -> USHORT conversion
//
__inline
HRESULT
Int8ToUShort (
__inn INT8 i8Operand ,
__outt __deref_out_range ( = = , i8Operand ) USHORT * pusResult )
{
HRESULT hr ;
if ( i8Operand > = 0 )
{
* pusResult = ( USHORT ) i8Operand ;
hr = S_OK ;
}
else
{
* pusResult = USHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT8 -> UINT16 conversion
//
# define Int8ToUInt16 Int8ToUShort
//
// INT8 -> WORD conversion
//
# define Int8ToWord Int8ToUShort
//
// INT8 -> UINT conversion
//
__inline
HRESULT
Int8ToUInt (
__inn INT8 i8Operand ,
__outt __deref_out_range ( = = , i8Operand ) UINT * puResult )
{
HRESULT hr ;
if ( i8Operand > = 0 )
{
* puResult = ( UINT ) i8Operand ;
hr = S_OK ;
}
else
{
* puResult = UINT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT8 -> UINT32 conversion
//
# define Int8ToUInt32 Int8ToUInt
//
// INT8 -> UINT_PTR conversion
//
__inline
HRESULT
Int8ToUIntPtr (
__inn INT8 i8Operand ,
__outt __deref_out_range ( = = , i8Operand ) UINT_PTR * puResult )
{
HRESULT hr ;
if ( i8Operand > = 0 )
{
* puResult = ( UINT_PTR ) i8Operand ;
hr = S_OK ;
}
else
{
* puResult = UINT_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT8 -> ULONG conversion
//
__inline
HRESULT
Int8ToULong (
__inn INT8 i8Operand ,
__outt __deref_out_range ( = = , i8Operand ) ULONG * pulResult )
{
HRESULT hr ;
if ( i8Operand > = 0 )
{
* pulResult = ( ULONG ) i8Operand ;
hr = S_OK ;
}
else
{
* pulResult = ULONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT8 -> ULONG_PTR conversion
//
__inline
HRESULT
Int8ToULongPtr (
__inn INT8 i8Operand ,
__outt __deref_out_range ( = = , i8Operand ) ULONG_PTR * pulResult )
{
HRESULT hr ;
if ( i8Operand > = 0 )
{
* pulResult = ( ULONG_PTR ) i8Operand ;
hr = S_OK ;
}
else
{
* pulResult = ULONG_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT8 -> DWORD conversion
//
# define Int8ToDWord Int8ToULong
//
// INT8 -> DWORD_PTR conversion
//
# define Int8ToDWordPtr Int8ToULongPtr
//
// INT8 -> ULONGLONG conversion
//
__inline
HRESULT
Int8ToULongLong (
__inn INT8 i8Operand ,
__outt __deref_out_range ( = = , i8Operand ) ULONGLONG * pullResult )
{
HRESULT hr ;
if ( i8Operand > = 0 )
{
* pullResult = ( ULONGLONG ) i8Operand ;
hr = S_OK ;
}
else
{
* pullResult = ULONGLONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT8 -> DWORDLONG conversion
//
# define Int8ToDWordLong Int8ToULongLong
//
// INT8 -> ULONG64 conversion
//
# define Int8ToULong64 Int8ToULongLong
//
// INT8 -> DWORD64 conversion
//
# define Int8ToDWord64 Int8ToULongLong
//
// INT8 -> UINT64 conversion
//
# define Int8ToUInt64 Int8ToULongLong
//
// INT8 -> size_t conversion
//
# define Int8ToSizeT Int8ToUIntPtr
//
// INT8 -> SIZE_T conversion
//
# define Int8ToSIZET Int8ToULongPtr
//
// UINT8 -> INT8 conversion
//
__inline
HRESULT
UInt8ToInt8 (
__inn UINT8 u8Operand ,
__outt __deref_out_range ( = = , u8Operand ) INT8 * pi8Result )
{
HRESULT hr ;
if ( u8Operand < = INT8_MAX )
{
* pi8Result = ( INT8 ) u8Operand ;
hr = S_OK ;
}
else
{
* pi8Result = INT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT8 -> CHAR conversion
//
__forceinline
HRESULT
UInt8ToChar (
__inn UINT8 u8Operand ,
__outt __deref_out_range ( = = , u8Operand ) CHAR * pch )
{
# ifdef _CHAR_UNSIGNED
* pch = ( CHAR ) u8Operand ;
return S_OK ;
# else
return UInt8ToInt8 ( u8Operand , ( INT8 * ) pch ) ;
# endif
}
//
// BYTE -> INT8 conversion
//
__inline
HRESULT
ByteToInt8 (
__inn BYTE bOperand ,
__outt __deref_out_range ( = = , bOperand ) INT8 * pi8Result )
{
HRESULT hr ;
if ( bOperand < = INT8_MAX )
{
* pi8Result = ( INT8 ) bOperand ;
hr = S_OK ;
}
else
{
* pi8Result = INT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// BYTE -> CHAR conversion
//
__forceinline
HRESULT
ByteToChar (
__inn BYTE bOperand ,
__outt __deref_out_range ( = = , bOperand ) CHAR * pch )
{
# ifdef _CHAR_UNSIGNED
* pch = ( CHAR ) bOperand ;
return S_OK ;
# else
return ByteToInt8 ( bOperand , ( INT8 * ) pch ) ;
# endif
}
//
// SHORT -> INT8 conversion
//
__inline
HRESULT
ShortToInt8 (
__inn SHORT sOperand ,
__outt __deref_out_range ( = = , sOperand ) INT8 * pi8Result )
{
HRESULT hr ;
if ( ( sOperand > = INT8_MIN ) & & ( sOperand < = INT8_MAX ) )
{
* pi8Result = ( INT8 ) sOperand ;
hr = S_OK ;
}
else
{
* pi8Result = INT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// SHORT -> UCHAR conversion
//
__inline
HRESULT
ShortToUChar (
__inn SHORT sOperand ,
__outt __deref_out_range ( = = , sOperand ) UCHAR * pch )
{
HRESULT hr ;
if ( ( sOperand > = 0 ) & & ( sOperand < = 255 ) )
{
* pch = ( UCHAR ) sOperand ;
hr = S_OK ;
}
else
{
* pch = ' \0 ' ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// SHORT -> CHAR conversion
//
__forceinline
HRESULT
ShortToChar (
__inn SHORT sOperand ,
__outt __deref_out_range ( = = , sOperand ) CHAR * pch )
{
# ifdef _CHAR_UNSIGNED
return ShortToUChar ( sOperand , ( UCHAR * ) pch ) ;
# else
return ShortToInt8 ( sOperand , ( INT8 * ) pch ) ;
# endif // _CHAR_UNSIGNED
}
//
// SHORT -> UINT8 conversion
//
__inline
HRESULT
ShortToUInt8 (
__inn SHORT sOperand ,
__outt __deref_out_range ( = = , sOperand ) UINT8 * pui8Result )
{
HRESULT hr ;
if ( ( sOperand > = 0 ) & & ( sOperand < = UINT8_MAX ) )
{
* pui8Result = ( UINT8 ) sOperand ;
hr = S_OK ;
}
else
{
* pui8Result = UINT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// SHORT -> BYTE conversion
//
# define ShortToByte ShortToUInt8
//
// SHORT -> USHORT conversion
//
__inline
HRESULT
ShortToUShort (
__inn SHORT sOperand ,
__outt __deref_out_range ( = = , sOperand ) USHORT * pusResult )
{
HRESULT hr ;
if ( sOperand > = 0 )
{
* pusResult = ( USHORT ) sOperand ;
hr = S_OK ;
}
else
{
* pusResult = USHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// SHORT -> UINT16 conversion
//
# define ShortToUInt16 ShortToUShort
//
// SHORT -> WORD conversion
//
# define ShortToWord ShortToUShort
//
// SHORT -> UINT conversion
//
__inline
HRESULT
ShortToUInt (
__inn SHORT sOperand ,
__outt __deref_out_range ( = = , sOperand ) UINT * puResult )
{
HRESULT hr ;
if ( sOperand > = 0 )
{
* puResult = ( UINT ) sOperand ;
hr = S_OK ;
}
else
{
* puResult = UINT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// SHORT -> UINT32 conversion
//
# define ShortToUInt32 ShortToUInt
//
// SHORT -> UINT_PTR conversion
//
__inline
HRESULT
ShortToUIntPtr (
__inn SHORT sOperand ,
__outt __deref_out_range ( = = , sOperand ) UINT_PTR * puResult )
{
HRESULT hr ;
if ( sOperand > = 0 )
{
* puResult = ( UINT_PTR ) sOperand ;
hr = S_OK ;
}
else
{
* puResult = UINT_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// SHORT -> ULONG conversion
//
__inline
HRESULT
ShortToULong (
__inn SHORT sOperand ,
__outt __deref_out_range ( = = , sOperand ) ULONG * pulResult )
{
HRESULT hr ;
if ( sOperand > = 0 )
{
* pulResult = ( ULONG ) sOperand ;
hr = S_OK ;
}
else
{
* pulResult = ULONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// SHORT -> ULONG_PTR conversion
//
__inline
HRESULT
ShortToULongPtr (
__inn SHORT sOperand ,
__outt __deref_out_range ( = = , sOperand ) ULONG_PTR * pulResult )
{
HRESULT hr ;
if ( sOperand > = 0 )
{
* pulResult = ( ULONG_PTR ) sOperand ;
hr = S_OK ;
}
else
{
* pulResult = ULONG_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// SHORT -> DWORD conversion
//
# define ShortToDWord ShortToULong
//
// SHORT -> DWORD_PTR conversion
//
__inline
HRESULT
ShortToDWordPtr (
__inn SHORT sOperand ,
__outt __deref_out_range ( = = , sOperand ) DWORD_PTR * pdwResult )
{
HRESULT hr ;
if ( sOperand > = 0 )
{
* pdwResult = ( DWORD_PTR ) sOperand ;
hr = S_OK ;
}
else
{
* pdwResult = DWORD_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// SHORT -> ULONGLONG conversion
//
__inline
HRESULT
ShortToULongLong (
__inn SHORT sOperand ,
__outt __deref_out_range ( = = , sOperand ) ULONGLONG * pullResult )
{
HRESULT hr ;
if ( sOperand > = 0 )
{
* pullResult = ( ULONGLONG ) sOperand ;
hr = S_OK ;
}
else
{
* pullResult = ULONGLONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// SHORT -> DWORDLONG conversion
//
# define ShortToDWordLong ShortToULongLong
//
// SHORT -> ULONG64 conversion
//
# define ShortToULong64 ShortToULongLong
//
// SHORT -> DWORD64 conversion
//
# define ShortToDWord64 ShortToULongLong
//
// SHORT -> UINT64 conversion
//
# define ShortToUInt64 ShortToULongLong
//
// SHORT -> size_t conversion
//
# define ShortToSizeT ShortToUIntPtr
//
// SHORT -> SIZE_T conversion
//
# define ShortToSIZET ShortToULongPtr
//
// INT16 -> CHAR conversion
//
# define Int16ToChar ShortToChar
//
// INT16 -> INT8 conversion
//
# define Int16ToInt8 ShortToInt8
//
// INT16 -> UCHAR conversion
//
# define Int16ToUChar ShortToUChar
//
// INT16 -> UINT8 conversion
//
# define Int16ToUInt8 ShortToUInt8
//
// INT16 -> BYTE conversion
//
# define Int16ToByte ShortToUInt8
//
// INT16 -> USHORT conversion
//
# define Int16ToUShort ShortToUShort
//
// INT16 -> UINT16 conversion
//
# define Int16ToUInt16 ShortToUShort
//
// INT16 -> WORD conversion
//
# define Int16ToWord ShortToUShort
//
// INT16 -> UINT conversion
//
# define Int16ToUInt ShortToUInt
//
// INT16 -> UINT32 conversion
//
# define Int16ToUInt32 ShortToUInt
//
// INT16 -> UINT_PTR conversion
//
# define Int16ToUIntPtr ShortToUIntPtr
//
// INT16 -> ULONG conversion
//
# define Int16ToULong ShortToULong
//
// INT16 -> ULONG_PTR conversion
//
# define Int16ToULongPtr ShortToULongPtr
//
// INT16 -> DWORD conversion
//
# define Int16ToDWord ShortToULong
//
// INT16 -> DWORD_PTR conversion
//
# define Int16ToDWordPtr ShortToULongPtr
//
// INT16 -> ULONGLONG conversion
//
# define Int16ToULongLong ShortToULongLong
//
// INT16 -> DWORDLONG conversion
//
# define Int16ToDWordLong ShortToULongLong
//
// INT16 -> ULONG64 conversion
//
# define Int16ToULong64 ShortToULongLong
//
// INT16 -> DWORD64 conversion
//
# define Int16ToDWord64 ShortToULongLong
//
// INT16 -> UINT64 conversion
//
# define Int16ToUInt64 ShortToULongLong
//
// INT16 -> size_t conversion
//
# define Int16ToSizeT ShortToUIntPtr
//
// INT16 -> SIZE_T conversion
//
# define Int16ToSIZET ShortToULongPtr
//
// USHORT -> INT8 conversion
//
__inline
HRESULT
UShortToInt8 (
__inn USHORT usOperand ,
__outt __deref_out_range ( = = , usOperand ) INT8 * pi8Result )
{
HRESULT hr ;
if ( usOperand < = INT8_MAX )
{
* pi8Result = ( INT8 ) usOperand ;
hr = S_OK ;
}
else
{
* pi8Result = INT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// USHORT -> UCHAR conversion
//
__inline
HRESULT
UShortToUChar (
__inn USHORT usOperand ,
__outt __deref_out_range ( = = , usOperand ) UCHAR * pch )
{
HRESULT hr ;
if ( usOperand < = 255 )
{
* pch = ( UCHAR ) usOperand ;
hr = S_OK ;
}
else
{
* pch = ' \0 ' ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// USHORT -> CHAR conversion
//
__forceinline
HRESULT
UShortToChar (
__inn USHORT usOperand ,
__outt __deref_out_range ( = = , usOperand ) CHAR * pch )
{
# ifdef _CHAR_UNSIGNED
return UShortToUChar ( usOperand , ( UCHAR * ) pch ) ;
# else
return UShortToInt8 ( usOperand , ( INT8 * ) pch ) ;
# endif // _CHAR_UNSIGNED
}
//
// USHORT -> UINT8 conversion
//
__inline
HRESULT
UShortToUInt8 (
__inn USHORT usOperand ,
__outt __deref_out_range ( = = , usOperand ) UINT8 * pui8Result )
{
HRESULT hr ;
if ( usOperand < = UINT8_MAX )
{
* pui8Result = ( UINT8 ) usOperand ;
hr = S_OK ;
}
else
{
* pui8Result = UINT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// USHORT -> BYTE conversion
//
# define UShortToByte UShortToUInt8
//
// USHORT -> SHORT conversion
//
__inline
HRESULT
UShortToShort (
__inn USHORT usOperand ,
__outt __deref_out_range ( = = , usOperand ) SHORT * psResult )
{
HRESULT hr ;
if ( usOperand < = SHORT_MAX )
{
* psResult = ( SHORT ) usOperand ;
hr = S_OK ;
}
else
{
* psResult = SHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// USHORT -> INT16 conversion
//
# define UShortToInt16 UShortToShort
//
// UINT16 -> CHAR conversion
//
# define UInt16ToChar UShortToChar
//
// UINT16 -> INT8 conversion
//
# define UInt16ToInt8 UShortToInt8
//
// UINT16 -> UCHAR conversion
//
# define UInt16ToUChar UShortToUChar
//
// UINT16 -> UINT8 conversion
//
# define UInt16ToUInt8 UShortToUInt8
//
// UINT16 -> BYTE conversion
//
# define UInt16ToByte UShortToUInt8
//
// UINT16 -> SHORT conversion
//
# define UInt16ToShort UShortToShort
//
// UINT16 -> INT16 conversion
//
# define UInt16ToInt16 UShortToShort
//
// WORD -> INT8 conversion
//
# define WordToInt8 UShortToInt8
//
// WORD -> CHAR conversion
//
# define WordToChar UShortToChar
//
// WORD -> UCHAR conversion
//
# define WordToUChar UShortToUChar
//
// WORD -> UINT8 conversion
//
# define WordToUInt8 UShortToUInt8
//
// WORD -> BYTE conversion
//
# define WordToByte UShortToUInt8
//
// WORD -> SHORT conversion
//
# define WordToShort UShortToShort
//
// WORD -> INT16 conversion
//
# define WordToInt16 UShortToShort
//
// INT -> INT8 conversion
//
__inline
HRESULT
IntToInt8 (
__inn INT iOperand ,
__outt __deref_out_range ( = = , iOperand ) INT8 * pi8Result )
{
HRESULT hr ;
if ( ( iOperand > = INT8_MIN ) & & ( iOperand < = INT8_MAX ) )
{
* pi8Result = ( INT8 ) iOperand ;
hr = S_OK ;
}
else
{
* pi8Result = INT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT -> UCHAR conversion
//
__inline
HRESULT
IntToUChar (
__inn INT iOperand ,
__outt __deref_out_range ( = = , iOperand ) UCHAR * pch )
{
HRESULT hr ;
if ( ( iOperand > = 0 ) & & ( iOperand < = 255 ) )
{
* pch = ( UCHAR ) iOperand ;
hr = S_OK ;
}
else
{
* pch = ' \0 ' ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT -> CHAR conversion
//
__forceinline
HRESULT
IntToChar (
__inn INT iOperand ,
__outt __deref_out_range ( = = , iOperand ) CHAR * pch )
{
# ifdef _CHAR_UNSIGNED
return IntToUChar ( iOperand , ( UCHAR * ) pch ) ;
# else
return IntToInt8 ( iOperand , ( INT8 * ) pch ) ;
# endif // _CHAR_UNSIGNED
}
//
// INT -> BYTE conversion
//
# define IntToByte IntToUInt8
//
// INT -> UINT8 conversion
//
__inline
HRESULT
IntToUInt8 (
__inn INT iOperand ,
__outt __deref_out_range ( = = , iOperand ) UINT8 * pui8Result )
{
HRESULT hr ;
if ( ( iOperand > = 0 ) & & ( iOperand < = UINT8_MAX ) )
{
* pui8Result = ( UINT8 ) iOperand ;
hr = S_OK ;
}
else
{
* pui8Result = UINT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT -> SHORT conversion
//
__inline
HRESULT
IntToShort (
__inn INT iOperand ,
__outt __deref_out_range ( = = , iOperand ) SHORT * psResult )
{
HRESULT hr ;
if ( ( iOperand > = SHORT_MIN ) & & ( iOperand < = SHORT_MAX ) )
{
* psResult = ( SHORT ) iOperand ;
hr = S_OK ;
}
else
{
* psResult = SHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT -> INT16 conversion
//
# define IntToInt16 IntToShort
//
// INT -> USHORT conversion
//
__inline
HRESULT
IntToUShort (
__inn INT iOperand ,
__outt __deref_out_range ( = = , iOperand ) USHORT * pusResult )
{
HRESULT hr ;
if ( ( iOperand > = 0 ) & & ( iOperand < = USHORT_MAX ) )
{
* pusResult = ( USHORT ) iOperand ;
hr = S_OK ;
}
else
{
* pusResult = USHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT -> UINT16 conversion
//
# define IntToUInt16 IntToUShort
//
// INT -> WORD conversion
//
# define IntToWord IntToUShort
//
// INT -> UINT conversion
//
__inline
HRESULT
IntToUInt (
__inn INT iOperand ,
__outt __deref_out_range ( = = , iOperand ) UINT * puResult )
{
HRESULT hr ;
if ( iOperand > = 0 )
{
* puResult = ( UINT ) iOperand ;
hr = S_OK ;
}
else
{
* puResult = UINT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT -> UINT_PTR conversion
//
# ifdef _WIN64
# define IntToUIntPtr IntToULongLong
# else
# define IntToUIntPtr IntToUInt
# endif
//
// INT -> ULONG conversion
//
__inline
HRESULT
IntToULong (
__inn INT iOperand ,
__outt __deref_out_range ( = = , iOperand ) ULONG * pulResult )
{
HRESULT hr ;
if ( iOperand > = 0 )
{
* pulResult = ( ULONG ) iOperand ;
hr = S_OK ;
}
else
{
* pulResult = ULONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT -> ULONG_PTR conversion
//
# ifdef _WIN64
# define IntToULongPtr IntToULongLong
# else
# define IntToULongPtr IntToULong
# endif
//
// INT -> DWORD conversion
//
# define IntToDWord IntToULong
//
// INT -> DWORD_PTR conversion
//
# define IntToDWordPtr IntToULongPtr
//
// INT -> ULONGLONG conversion
//
__inline
HRESULT
IntToULongLong (
__inn INT iOperand ,
__outt __deref_out_range ( = = , iOperand ) ULONGLONG * pullResult )
{
HRESULT hr ;
if ( iOperand > = 0 )
{
* pullResult = ( ULONGLONG ) iOperand ;
hr = S_OK ;
}
else
{
* pullResult = ULONGLONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT -> DWORDLONG conversion
//
# define IntToDWordLong IntToULongLong
//
// INT -> ULONG64 conversion
//
# define IntToULong64 IntToULongLong
//
// INT -> DWORD64 conversion
//
# define IntToDWord64 IntToULongLong
//
// INT -> UINT64 conversion
//
# define IntToUInt64 IntToULongLong
//
// INT -> size_t conversion
//
# define IntToSizeT IntToUIntPtr
//
// INT -> SIZE_T conversion
//
# define IntToSIZET IntToULongPtr
//
// INT32 -> CHAR conversion
//
# define Int32ToChar IntToChar
//
// INT32 -> INT328 conversion
//
# define Int32ToInt8 IntToInt8
//
// INT32 -> UCHAR conversion
//
# define Int32ToUChar IntToUChar
//
// INT32 -> BYTE conversion
//
# define Int32ToByte IntToUInt8
//
// INT32 -> UINT8 conversion
//
# define Int32ToUInt8 IntToUInt8
//
// INT32 -> SHORT conversion
//
# define Int32ToShort IntToShort
//
// INT32 -> INT16 conversion
//
# define Int32ToInt16 IntToShort
//
// INT32 -> USHORT conversion
//
# define Int32ToUShort IntToUShort
//
// INT32 -> UINT16 conversion
//
# define Int32ToUInt16 IntToUShort
//
// INT32 -> WORD conversion
//
# define Int32ToWord IntToUShort
//
// INT32 -> UINT conversion
//
# define Int32ToUInt IntToUInt
//
// INT32 -> UINT32 conversion
//
# define Int32ToUInt32 IntToUInt
//
// INT32 -> UINT_PTR conversion
//
# define Int32ToUIntPtr IntToUIntPtr
//
// INT32 -> ULONG conversion
//
# define Int32ToULong IntToULong
//
// INT32 -> ULONG_PTR conversion
//
# define Int32ToULongPtr IntToULongPtr
//
// INT32 -> DWORD conversion
//
# define Int32ToDWord IntToULong
//
// INT32 -> DWORD_PTR conversion
//
# define Int32ToDWordPtr IntToULongPtr
//
// INT32 -> ULONGLONG conversion
//
# define Int32ToULongLong IntToULongLong
//
// INT32 -> DWORDLONG conversion
//
# define Int32ToDWordLong IntToULongLong
//
// INT32 -> ULONG64 conversion
//
# define Int32ToULong64 IntToULongLong
//
// INT32 -> DWORD64 conversion
//
# define Int32ToDWord64 IntToULongLong
//
// INT32 -> UINT64 conversion
//
# define Int32ToUInt64 IntToULongLong
//
// INT32 -> size_t conversion
//
# define Int32ToSizeT IntToUIntPtr
//
// INT32 -> SIZE_T conversion
//
# define Int32ToSIZET IntToULongPtr
//
// INT_PTR -> INT8 conversion
//
__inline
HRESULT
IntPtrToInt8 (
__inn INT_PTR iOperand ,
__outt __deref_out_range ( = = , iOperand ) INT8 * pi8Result )
{
HRESULT hr ;
if ( ( iOperand > = INT8_MIN ) & & ( iOperand < = INT8_MAX ) )
{
* pi8Result = ( INT8 ) iOperand ;
hr = S_OK ;
}
else
{
* pi8Result = INT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT_PTR -> UCHAR conversion
//
__inline
HRESULT
IntPtrToUChar (
__inn INT_PTR iOperand ,
__outt __deref_out_range ( = = , iOperand ) UCHAR * pch )
{
HRESULT hr ;
if ( ( iOperand > = 0 ) & & ( iOperand < = 255 ) )
{
* pch = ( UCHAR ) iOperand ;
hr = S_OK ;
}
else
{
* pch = ' \0 ' ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT_PTR -> CHAR conversion
//
__forceinline
HRESULT
IntPtrToChar (
__inn INT_PTR iOperand ,
__outt __deref_out_range ( = = , iOperand ) CHAR * pch )
{
# ifdef _CHAR_UNSIGNED
return IntPtrToUChar ( iOperand , ( UCHAR * ) pch ) ;
# else
return IntPtrToInt8 ( iOperand , ( INT8 * ) pch ) ;
# endif // _CHAR_UNSIGNED
}
//
// INT_PTR -> UINT8 conversion
//
__inline
HRESULT
IntPtrToUInt8 (
__inn INT_PTR iOperand ,
__outt __deref_out_range ( = = , iOperand ) UINT8 * pui8Result )
{
HRESULT hr ;
if ( ( iOperand > = 0 ) & & ( iOperand < = UINT8_MAX ) )
{
* pui8Result = ( UINT8 ) iOperand ;
hr = S_OK ;
}
else
{
* pui8Result = UINT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT_PTR -> BYTE conversion
//
# define IntPtrToByte IntPtrToUInt8
//
// INT_PTR -> SHORT conversion
//
__inline
HRESULT
IntPtrToShort (
__inn INT_PTR iOperand ,
__outt __deref_out_range ( = = , iOperand ) SHORT * psResult )
{
HRESULT hr ;
if ( ( iOperand > = SHORT_MIN ) & & ( iOperand < = SHORT_MAX ) )
{
* psResult = ( SHORT ) iOperand ;
hr = S_OK ;
}
else
{
* psResult = SHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT_PTR -> INT16 conversion
//
# define IntPtrToInt16 IntPtrToShort
//
// INT_PTR -> USHORT conversion
//
__inline
HRESULT
IntPtrToUShort (
__inn INT_PTR iOperand ,
__outt __deref_out_range ( = = , iOperand ) USHORT * pusResult )
{
HRESULT hr ;
if ( ( iOperand > = 0 ) & & ( iOperand < = USHORT_MAX ) )
{
* pusResult = ( USHORT ) iOperand ;
hr = S_OK ;
}
else
{
* pusResult = USHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// INT_PTR -> UINT16 conversion
//
# define IntPtrToUInt16 IntPtrToUShort
//
// INT_PTR -> WORD conversion
//
# define IntPtrToWord IntPtrToUShort
//
// INT_PTR -> INT conversion
//
# ifdef _WIN64
# define IntPtrToInt LongLongToInt
# else
__inline
HRESULT
IntPtrToInt (
__inn INT_PTR iOperand ,
__outt __deref_out_range ( = = , iOperand ) INT * piResult )
{
* piResult = ( INT ) iOperand ;
return S_OK ;
}
# endif
//
// INT_PTR -> INT32 conversion
//
# define IntPtrToInt32 IntPtrToInt
//
// INT_PTR -> UINT conversion
//
# ifdef _WIN64
# define IntPtrToUInt LongLongToUInt
# else
__inline
HRESULT
IntPtrToUInt (
__inn INT_PTR iOperand ,
__outt __deref_out_range ( = = , iOperand ) UINT * puResult )
{
HRESULT hr ;
if ( iOperand > = 0 )
{
* puResult = ( UINT ) iOperand ;
hr = S_OK ;
}
else
{
* puResult = UINT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
# endif
//
// INT_PTR -> UINT32 conversion
//
# define IntPtrToUInt32 IntPtrToUInt
//
// INT_PTR -> UINT_PTR conversion
//
# ifdef _WIN64
# define IntPtrToUIntPtr LongLongToULongLong
# else
__inline
HRESULT
IntPtrToUIntPtr (
__inn INT_PTR iOperand ,
__outt __deref_out_range ( = = , iOperand ) UINT_PTR * puResult )
{
HRESULT hr ;
if ( iOperand > = 0 )
{
* puResult = ( UINT_PTR ) iOperand ;
hr = S_OK ;
}
else
{
* puResult = UINT_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
# endif
//
// INT_PTR -> LONG conversion
//
# ifdef _WIN64
# define IntPtrToLong LongLongToLong
# else
__inline
HRESULT
IntPtrToLong (
__inn INT_PTR iOperand ,
__outt __deref_out_range ( = = , iOperand ) LONG * plResult )
{
* plResult = ( LONG ) iOperand ;
return S_OK ;
}
# endif
//
// INT_PTR -> LONG_PTR conversion
//
__inline
HRESULT
IntPtrToLongPtr (
__inn INT_PTR iOperand ,
__outt __deref_out_range ( = = , iOperand ) LONG_PTR * plResult )
{
* plResult = ( LONG_PTR ) iOperand ;
return S_OK ;
}
//
// INT_PTR -> ULONG conversion
//
# ifdef _WIN64
# define IntPtrToULong LongLongToULong
# else
__inline
HRESULT
IntPtrToULong (
__inn INT_PTR iOperand ,
__outt __deref_out_range ( = = , iOperand ) ULONG * pulResult )
{
HRESULT hr ;
if ( iOperand > = 0 )
{
* pulResult = ( ULONG ) iOperand ;
hr = S_OK ;
}
else
{
* pulResult = ULONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
# endif
//
// INT_PTR -> ULONG_PTR conversion
//
# ifdef _WIN64
# define IntPtrToULongPtr LongLongToULongLong
# else
__inline
HRESULT
IntPtrToULongPtr (
__inn INT_PTR iOperand ,
__outt __deref_out_range ( = = , iOperand ) ULONG_PTR * pulResult )
{
HRESULT hr ;
if ( iOperand > = 0 )
{
* pulResult = ( ULONG_PTR ) iOperand ;
hr = S_OK ;
}
else
{
* pulResult = ULONG_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
# endif
//
// INT_PTR -> DWORD conversion
//
# define IntPtrToDWord IntPtrToULong
//
// INT_PTR -> DWORD_PTR conversion
//
# define IntPtrToDWordPtr IntPtrToULongPtr
//
// INT_PTR -> ULONGLONG conversion
//
# ifdef _WIN64
# define IntPtrToULongLong LongLongToULongLong
# else
__inline
HRESULT
IntPtrToULongLong (
__inn INT_PTR iOperand ,
__outt __deref_out_range ( = = , iOperand ) ULONGLONG * pullResult )
{
HRESULT hr ;
if ( iOperand > = 0 )
{
* pullResult = ( ULONGLONG ) iOperand ;
hr = S_OK ;
}
else
{
* pullResult = ULONGLONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
# endif
//
// INT_PTR -> DWORDLONG conversion
//
# define IntPtrToDWordLong IntPtrToULongLong
//
// INT_PTR -> ULONG64 conversion
//
# define IntPtrToULong64 IntPtrToULongLong
//
// INT_PTR -> DWORD64 conversion
//
# define IntPtrToDWord64 IntPtrToULongLong
//
// INT_PTR -> UINT64 conversion
//
# define IntPtrToUInt64 IntPtrToULongLong
//
// INT_PTR -> size_t conversion
//
# define IntPtrToSizeT IntPtrToUIntPtr
//
// INT_PTR -> SIZE_T conversion
//
# define IntPtrToSIZET IntPtrToULongPtr
//
// UINT -> INT8 conversion
//
__inline
HRESULT
UIntToInt8 (
__inn UINT uOperand ,
__outt __deref_out_range ( = = , uOperand ) INT8 * pi8Result )
{
HRESULT hr ;
if ( uOperand < = INT8_MAX )
{
* pi8Result = ( INT8 ) uOperand ;
hr = S_OK ;
}
else
{
* pi8Result = INT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT -> UCHAR conversion
//
__inline
HRESULT
UIntToUChar (
__inn UINT uOperand ,
__outt __deref_out_range ( = = , uOperand ) UCHAR * pch )
{
HRESULT hr ;
if ( uOperand < = 255 )
{
* pch = ( UCHAR ) uOperand ;
hr = S_OK ;
}
else
{
* pch = ' \0 ' ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT -> CHAR conversion
//
__forceinline
HRESULT
UIntToChar (
__inn UINT uOperand ,
__outt __deref_out_range ( = = , uOperand ) CHAR * pch )
{
# ifdef _CHAR_UNSIGNED
return UIntToUChar ( uOperand , ( UCHAR * ) pch ) ;
# else
return UIntToInt8 ( uOperand , ( INT8 * ) pch ) ;
# endif
}
//
// UINT -> UINT8 conversion
//
__inline
HRESULT
UIntToUInt8 (
__inn UINT uOperand ,
__outt __deref_out_range ( = = , uOperand ) UINT8 * pui8Result )
{
HRESULT hr ;
if ( uOperand < = UINT8_MAX )
{
* pui8Result = ( UINT8 ) uOperand ;
hr = S_OK ;
}
else
{
* pui8Result = UINT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT -> BYTE conversion
//
# define UIntToByte UIntToUInt8
//
// UINT -> SHORT conversion
//
__inline
HRESULT
UIntToShort (
__inn UINT uOperand ,
__outt __deref_out_range ( = = , uOperand ) SHORT * psResult )
{
HRESULT hr ;
if ( uOperand < = SHORT_MAX )
{
* psResult = ( SHORT ) uOperand ;
hr = S_OK ;
}
else
{
* psResult = SHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT -> INT16 conversion
//
# define UIntToInt16 UIntToShort
//
// UINT -> USHORT conversion
//
__inline
HRESULT
UIntToUShort (
__inn UINT uOperand ,
__outt __deref_out_range ( = = , uOperand ) USHORT * pusResult )
{
HRESULT hr ;
if ( uOperand < = USHORT_MAX )
{
* pusResult = ( USHORT ) uOperand ;
hr = S_OK ;
}
else
{
* pusResult = USHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT -> UINT16 conversion
//
# define UIntToUInt16 UIntToUShort
//
// UINT -> WORD conversion
//
# define UIntToWord UIntToUShort
//
// UINT -> INT conversion
//
__inline
HRESULT
UIntToInt (
__inn UINT uOperand ,
__outt __deref_out_range ( = = , uOperand ) INT * piResult )
{
HRESULT hr ;
if ( uOperand < = INT_MAX )
{
* piResult = ( INT ) uOperand ;
hr = S_OK ;
}
else
{
* piResult = INT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT -> INT32 conversion
//
# define UIntToInt32 UIntToInt
//
// UINT -> INT_PTR conversion
//
# ifdef _WIN64
__inline
HRESULT
UIntToIntPtr (
__inn UINT uOperand ,
__outt __deref_out_range ( = = , uOperand ) INT_PTR * piResult )
{
* piResult = uOperand ;
return S_OK ;
}
# else
# define UIntToIntPtr UIntToInt
# endif
//
// UINT -> LONG conversion
//
__inline
HRESULT
UIntToLong (
__inn UINT uOperand ,
__outt __deref_out_range ( = = , uOperand ) LONG * plResult )
{
HRESULT hr ;
if ( uOperand < = INT32_MAX )
{
* plResult = ( LONG ) uOperand ;
hr = S_OK ;
}
else
{
* plResult = LONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT -> LONG_PTR conversion
//
# ifdef _WIN64
__inline
HRESULT
UIntToLongPtr (
__inn UINT uOperand ,
__outt __deref_out_range ( = = , uOperand ) LONG_PTR * plResult )
{
* plResult = uOperand ;
return S_OK ;
}
# else
# define UIntToLongPtr UIntToLong
# endif
//
// UINT -> ptrdiff_t conversion
//
# define UIntToPtrdiffT UIntToIntPtr
//
// UINT -> SSIZE_T conversion
//
# define UIntToSSIZET UIntToLongPtr
//
// UINT32 -> CHAR conversion
//
# define UInt32ToChar UIntToChar
//
// UINT32 -> INT8 conversion
//
# define UInt32ToInt8 UIntToInt8
//
// UINT32 -> UCHAR conversion
//
# define UInt32ToUChar UIntToUChar
//
// UINT32 -> UINT8 conversion
//
# define UInt32ToUInt8 UIntToUInt8
//
// UINT32 -> BYTE conversion
//
# define UInt32ToByte UInt32ToUInt8
//
// UINT32 -> SHORT conversion
//
# define UInt32ToShort UIntToShort
//
// UINT32 -> INT16 conversion
//
# define UInt32ToInt16 UIntToShort
//
// UINT32 -> USHORT conversion
//
# define UInt32ToUShort UIntToUShort
//
// UINT32 -> UINT16 conversion
//
# define UInt32ToUInt16 UIntToUShort
//
// UINT32 -> WORD conversion
//
# define UInt32ToWord UIntToUShort
//
// UINT32 -> INT conversion
//
# define UInt32ToInt UIntToInt
//
// UINT32 -> INT_PTR conversion
//
# define UInt32ToIntPtr UIntToIntPtr
//
// UINT32 -> INT32 conversion
//
# define UInt32ToInt32 UIntToInt
//
// UINT32 -> LONG conversion
//
# define UInt32ToLong UIntToLong
//
// UINT32 -> LONG_PTR conversion
//
# define UInt32ToLongPtr UIntToLongPtr
//
// UINT32 -> ptrdiff_t conversion
//
# define UInt32ToPtrdiffT UIntToPtrdiffT
//
// UINT32 -> SSIZE_T conversion
//
# define UInt32ToSSIZET UIntToSSIZET
//
// UINT_PTR -> INT8 conversion
//
__inline
HRESULT
UIntPtrToInt8 (
__inn UINT_PTR uOperand ,
__outt __deref_out_range ( = = , uOperand ) INT8 * pi8Result )
{
HRESULT hr ;
if ( uOperand < = INT8_MAX )
{
* pi8Result = ( INT8 ) uOperand ;
hr = S_OK ;
}
else
{
* pi8Result = INT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT_PTR -> UCHAR conversion
//
__inline
HRESULT
UIntPtrToUChar (
__inn UINT_PTR uOperand ,
__outt __deref_out_range ( = = , uOperand ) UCHAR * pch )
{
HRESULT hr ;
if ( uOperand < = 255 )
{
* pch = ( UCHAR ) uOperand ;
hr = S_OK ;
}
else
{
* pch = ' \0 ' ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT_PTR -> CHAR conversion
//
__forceinline
HRESULT
UIntPtrToChar (
__inn UINT_PTR uOperand ,
__outt __deref_out_range ( = = , uOperand ) CHAR * pch )
{
# ifdef _CHAR_UNSIGNED
return UIntPtrToUChar ( uOperand , ( UCHAR * ) pch ) ;
# else
return UIntPtrToInt8 ( uOperand , ( INT8 * ) pch ) ;
# endif
}
//
// UINT_PTR -> UINT8 conversion
//
__inline
HRESULT
UIntPtrToUInt8 (
__inn UINT_PTR uOperand ,
__outt __deref_out_range ( = = , uOperand ) UINT8 * pu8Result )
{
HRESULT hr ;
if ( uOperand < = UINT8_MAX )
{
* pu8Result = ( UINT8 ) uOperand ;
hr = S_OK ;
}
else
{
* pu8Result = UINT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT_PTR -> BYTE conversion
//
# define UIntPtrToByte UIntPtrToUInt8
//
// UINT_PTR -> SHORT conversion
//
__inline
HRESULT
UIntPtrToShort (
__inn UINT_PTR uOperand ,
__outt __deref_out_range ( = = , uOperand ) SHORT * psResult )
{
HRESULT hr ;
if ( uOperand < = SHORT_MAX )
{
* psResult = ( SHORT ) uOperand ;
hr = S_OK ;
}
else
{
* psResult = SHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT_PTR -> INT16 conversion
//
__inline
HRESULT
UIntPtrToInt16 (
__inn UINT_PTR uOperand ,
__outt __deref_out_range ( = = , uOperand ) INT16 * pi16Result )
{
HRESULT hr ;
if ( uOperand < = INT16_MAX )
{
* pi16Result = ( INT16 ) uOperand ;
hr = S_OK ;
}
else
{
* pi16Result = INT16_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT_PTR -> USHORT conversion
//
__inline
HRESULT
UIntPtrToUShort (
__inn UINT_PTR uOperand ,
__outt __deref_out_range ( = = , uOperand ) USHORT * pusResult )
{
HRESULT hr ;
if ( uOperand < = USHORT_MAX )
{
* pusResult = ( USHORT ) uOperand ;
hr = S_OK ;
}
else
{
* pusResult = USHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT_PTR -> UINT16 conversion
//
__inline
HRESULT
UIntPtrToUInt16 (
__inn UINT_PTR uOperand ,
__outt __deref_out_range ( = = , uOperand ) UINT16 * pu16Result )
{
HRESULT hr ;
if ( uOperand < = UINT16_MAX )
{
* pu16Result = ( UINT16 ) uOperand ;
hr = S_OK ;
}
else
{
* pu16Result = UINT16_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT_PTR -> WORD conversion
//
# define UIntPtrToWord UIntPtrToUShort
//
// UINT_PTR -> INT conversion
//
__inline
HRESULT
UIntPtrToInt (
__inn UINT_PTR uOperand ,
__outt __deref_out_range ( = = , uOperand ) INT * piResult )
{
HRESULT hr ;
if ( uOperand < = INT_MAX )
{
* piResult = ( INT ) uOperand ;
hr = S_OK ;
}
else
{
* piResult = INT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT_PTR -> INT32 conversion
//
# define UIntPtrToInt32 UIntPtrToInt
//
// UINT_PTR -> INT_PTR conversion
//
__inline
HRESULT
UIntPtrToIntPtr (
__inn UINT_PTR uOperand ,
__outt __deref_out_range ( = = , uOperand ) INT_PTR * piResult )
{
HRESULT hr ;
if ( uOperand < = INT_PTR_MAX )
{
* piResult = ( INT_PTR ) uOperand ;
hr = S_OK ;
}
else
{
* piResult = INT_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT_PTR -> UINT conversion
//
# ifdef _WIN64
# define UIntPtrToUInt ULongLongToUInt
# else
__inline
HRESULT
UIntPtrToUInt (
__inn UINT_PTR uOperand ,
__outt __deref_out_range ( = = , uOperand ) UINT * puResult )
{
* puResult = ( UINT ) uOperand ;
return S_OK ;
}
# endif
//
// UINT_PTR -> UINT32 conversion
//
# define UIntPtrToUInt32 UIntPtrToUInt
//
// UINT_PTR -> LONG conversion
//
__inline
HRESULT
UIntPtrToLong (
__inn UINT_PTR uOperand ,
__outt __deref_out_range ( = = , uOperand ) LONG * plResult )
{
HRESULT hr ;
if ( uOperand < = INT32_MAX )
{
* plResult = ( LONG ) uOperand ;
hr = S_OK ;
}
else
{
* plResult = LONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT_PTR -> LONG_PTR conversion
//
__inline
HRESULT
UIntPtrToLongPtr (
__inn UINT_PTR uOperand ,
__outt __deref_out_range ( = = , uOperand ) LONG_PTR * plResult )
{
HRESULT hr ;
if ( uOperand < = LONG_PTR_MAX )
{
* plResult = ( LONG_PTR ) uOperand ;
hr = S_OK ;
}
else
{
* plResult = LONG_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT_PTR -> ULONG conversion
//
# ifdef _WIN64
# define UIntPtrToULong ULongLongToULong
# else
__inline
HRESULT
UIntPtrToULong (
__inn UINT_PTR uOperand ,
__outt __deref_out_range ( = = , uOperand ) ULONG * pulResult )
{
* pulResult = ( ULONG ) uOperand ;
return S_OK ;
}
# endif
//
// UINT_PTR -> DWORD conversion
//
# define UIntPtrToDWord UIntPtrToULong
//
// UINT_PTR -> LONGLONG conversion
//
# ifdef _WIN64
# define UIntPtrToLongLong ULongLongToLongLong
# else
__inline
HRESULT
UIntPtrToLongLong (
__inn UINT_PTR uOperand ,
__outt __deref_out_range ( = = , uOperand ) LONGLONG * pllResult )
{
* pllResult = ( LONGLONG ) uOperand ;
return S_OK ;
}
# endif
//
// UINT_PTR -> LONG64 conversion
//
# define UIntPtrToLong64 UIntPtrToLongLong
//
// UINT_PTR -> INT64 conversion
//
# define UIntPtrToInt64 UIntPtrToLongLong
//
// UINT_PTR -> ptrdiff_t conversion
//
# define UIntPtrToPtrdiffT UIntPtrToIntPtr
//
// UINT_PTR -> SSIZE_T conversion
//
# define UIntPtrToSSIZET UIntPtrToLongPtr
//
// LONG -> INT8 conversion
//
__inline
HRESULT
LongToInt8 (
__inn LONG lOperand ,
__outt __deref_out_range ( = = , lOperand ) INT8 * pi8Result )
{
HRESULT hr ;
if ( ( lOperand > = INT8_MIN ) & & ( lOperand < = INT8_MAX ) )
{
* pi8Result = ( INT8 ) lOperand ;
hr = S_OK ;
}
else
{
* pi8Result = INT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONG -> UCHAR conversion
//
__inline
HRESULT
LongToUChar (
__inn LONG lOperand ,
__outt __deref_out_range ( = = , lOperand ) UCHAR * pch )
{
HRESULT hr ;
if ( ( lOperand > = 0 ) & & ( lOperand < = 255 ) )
{
* pch = ( UCHAR ) lOperand ;
hr = S_OK ;
}
else
{
* pch = ' \0 ' ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONG -> CHAR conversion
//
__forceinline
HRESULT
LongToChar (
__inn LONG lOperand ,
__outt __deref_out_range ( = = , lOperand ) CHAR * pch )
{
# ifdef _CHAR_UNSIGNED
return LongToUChar ( lOperand , ( UCHAR * ) pch ) ;
# else
return LongToInt8 ( lOperand , ( INT8 * ) pch ) ;
# endif
}
//
// LONG -> UINT8 conversion
//
__inline
HRESULT
LongToUInt8 (
__inn LONG lOperand ,
__outt __deref_out_range ( = = , lOperand ) UINT8 * pui8Result )
{
HRESULT hr ;
if ( ( lOperand > = 0 ) & & ( lOperand < = UINT8_MAX ) )
{
* pui8Result = ( UINT8 ) lOperand ;
hr = S_OK ;
}
else
{
* pui8Result = UINT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONG -> BYTE conversion
//
# define LongToByte LongToUInt8
//
// LONG -> SHORT conversion
//
__inline
HRESULT
LongToShort (
__inn LONG lOperand ,
__outt __deref_out_range ( = = , lOperand ) SHORT * psResult )
{
HRESULT hr ;
if ( ( lOperand > = SHORT_MIN ) & & ( lOperand < = SHORT_MAX ) )
{
* psResult = ( SHORT ) lOperand ;
hr = S_OK ;
}
else
{
* psResult = SHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONG -> INT16 conversion
//
# define LongToInt16 LongToShort
//
// LONG -> USHORT conversion
//
__inline
HRESULT
LongToUShort (
__inn LONG lOperand ,
__outt __deref_out_range ( = = , lOperand ) USHORT * pusResult )
{
HRESULT hr ;
if ( ( lOperand > = 0 ) & & ( lOperand < = USHORT_MAX ) )
{
* pusResult = ( USHORT ) lOperand ;
hr = S_OK ;
}
else
{
* pusResult = USHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONG -> UINT16 conversion
//
# define LongToUInt16 LongToUShort
//
// LONG -> WORD conversion
//
# define LongToWord LongToUShort
//
// LONG -> INT conversion
//
__inline
HRESULT
LongToInt (
__inn LONG lOperand ,
__outt __deref_out_range ( = = , lOperand ) INT * piResult )
{
C_ASSERT ( sizeof ( INT ) = = sizeof ( LONG ) ) ;
* piResult = ( INT ) lOperand ;
return S_OK ;
}
//
// LONG -> INT32 conversion
//
# define LongToInt32 LongToInt
//
// LONG -> INT_PTR conversion
//
# ifdef _WIN64
__inline
HRESULT
LongToIntPtr (
__inn LONG lOperand ,
__outt __deref_out_range ( = = , lOperand ) INT_PTR * piResult )
{
* piResult = lOperand ;
return S_OK ;
}
# else
# define LongToIntPtr LongToInt
# endif
//
// LONG -> UINT conversion
//
__inline
HRESULT
LongToUInt (
__inn LONG lOperand ,
__outt __deref_out_range ( = = , lOperand ) UINT * puResult )
{
HRESULT hr ;
if ( lOperand > = 0 )
{
* puResult = ( UINT ) lOperand ;
hr = S_OK ;
}
else
{
* puResult = UINT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONG -> UINT32 conversion
//
# define LongToUInt32 LongToUInt
//
// LONG -> UINT_PTR conversion
//
# ifdef _WIN64
__inline
HRESULT
LongToUIntPtr (
__inn LONG lOperand ,
__outt __deref_out_range ( = = , lOperand ) UINT_PTR * puResult )
{
HRESULT hr ;
if ( lOperand > = 0 )
{
* puResult = ( UINT_PTR ) lOperand ;
hr = S_OK ;
}
else
{
* puResult = UINT_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
# else
# define LongToUIntPtr LongToUInt
# endif
//
// LONG -> ULONG conversion
//
__inline
HRESULT
LongToULong (
__inn LONG lOperand ,
__outt __deref_out_range ( = = , lOperand ) ULONG * pulResult )
{
HRESULT hr ;
if ( lOperand > = 0 )
{
* pulResult = ( ULONG ) lOperand ;
hr = S_OK ;
}
else
{
* pulResult = ULONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONG -> ULONG_PTR conversion
//
# ifdef _WIN64
__inline
HRESULT
LongToULongPtr (
__inn LONG lOperand ,
__outt __deref_out_range ( = = , lOperand ) ULONG_PTR * pulResult )
{
HRESULT hr ;
if ( lOperand > = 0 )
{
* pulResult = ( ULONG_PTR ) lOperand ;
hr = S_OK ;
}
else
{
* pulResult = ULONG_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
# else
# define LongToULongPtr LongToULong
# endif
//
// LONG -> DWORD conversion
//
# define LongToDWord LongToULong
//
// LONG -> DWORD_PTR conversion
//
# define LongToDWordPtr LongToULongPtr
//
// LONG -> ULONGLONG conversion
//
__inline
HRESULT
LongToULongLong (
__inn LONG lOperand ,
__outt __deref_out_range ( = = , lOperand ) ULONGLONG * pullResult )
{
HRESULT hr ;
if ( lOperand > = 0 )
{
* pullResult = ( ULONGLONG ) lOperand ;
hr = S_OK ;
}
else
{
* pullResult = ULONGLONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONG -> DWORDLONG conversion
//
# define LongToDWordLong LongToULongLong
//
// LONG -> ULONG64 conversion
//
# define LongToULong64 LongToULongLong
//
// LONG -> DWORD64 conversion
//
# define LongToDWord64 LongToULongLong
//
// LONG -> UINT64 conversion
//
# define LongToUInt64 LongToULongLong
//
// LONG -> ptrdiff_t conversion
//
# define LongToPtrdiffT LongToIntPtr
//
// LONG -> size_t conversion
//
# define LongToSizeT LongToUIntPtr
//
// LONG -> SIZE_T conversion
//
# define LongToSIZET LongToULongPtr
//
// LONG_PTR -> INT8 conversion
//
__inline
HRESULT
LongPtrToInt8 (
__inn LONG_PTR lOperand ,
__outt __deref_out_range ( = = , lOperand ) INT8 * pi8Result )
{
HRESULT hr ;
if ( ( lOperand > = INT8_MIN ) & & ( lOperand < = INT8_MAX ) )
{
* pi8Result = ( INT8 ) lOperand ;
hr = S_OK ;
}
else
{
* pi8Result = INT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONG_PTR -> UCHAR conversion
//
__inline
HRESULT
LongPtrToUChar (
__inn LONG_PTR lOperand ,
__outt __deref_out_range ( = = , lOperand ) UCHAR * pch )
{
HRESULT hr ;
if ( ( lOperand > = 0 ) & & ( lOperand < = 255 ) )
{
* pch = ( UCHAR ) lOperand ;
hr = S_OK ;
}
else
{
* pch = ' \0 ' ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONG_PTR -> CHAR conversion
//
__forceinline
HRESULT
LongPtrToChar (
__inn LONG_PTR lOperand ,
__outt __deref_out_range ( = = , lOperand ) CHAR * pch )
{
# ifdef _CHAR_UNSIGNED
return LongPtrToUChar ( lOperand , ( UCHAR * ) pch ) ;
# else
return LongPtrToInt8 ( lOperand , ( INT8 * ) pch ) ;
# endif
}
//
// LONG_PTR -> UINT8 conversion
//
__inline
HRESULT
LongPtrToUInt8 (
__inn LONG_PTR lOperand ,
__outt __deref_out_range ( = = , lOperand ) UINT8 * pui8Result )
{
HRESULT hr ;
if ( ( lOperand > = 0 ) & & ( lOperand < = UINT8_MAX ) )
{
* pui8Result = ( UINT8 ) lOperand ;
hr = S_OK ;
}
else
{
* pui8Result = UINT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONG_PTR -> BYTE conversion
//
# define LongPtrToByte LongPtrToUInt8
//
// LONG_PTR -> SHORT conversion
//
__inline
HRESULT
LongPtrToShort (
__inn LONG_PTR lOperand ,
__outt __deref_out_range ( = = , lOperand ) SHORT * psResult )
{
HRESULT hr ;
if ( ( lOperand > = SHORT_MIN ) & & ( lOperand < = SHORT_MAX ) )
{
* psResult = ( SHORT ) lOperand ;
hr = S_OK ;
}
else
{
* psResult = SHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONG_PTR -> INT16 conversion
//
# define LongPtrToInt16 LongPtrToShort
//
// LONG_PTR -> USHORT conversion
//
__inline
HRESULT
LongPtrToUShort (
__inn LONG_PTR lOperand ,
__outt __deref_out_range ( = = , lOperand ) USHORT * pusResult )
{
HRESULT hr ;
if ( ( lOperand > = 0 ) & & ( lOperand < = USHORT_MAX ) )
{
* pusResult = ( USHORT ) lOperand ;
hr = S_OK ;
}
else
{
* pusResult = USHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONG_PTR -> UINT16 conversion
//
# define LongPtrToUInt16 LongPtrToUShort
//
// LONG_PTR -> WORD conversion
//
# define LongPtrToWord LongPtrToUShort
//
// LONG_PTR -> INT conversion
//
# ifdef _WIN64
# define LongPtrToInt LongLongToInt
# else
__inline
HRESULT
LongPtrToInt (
__inn LONG_PTR lOperand ,
__outt __deref_out_range ( = = , lOperand ) INT * piResult )
{
C_ASSERT ( sizeof ( INT ) = = sizeof ( LONG_PTR ) ) ;
* piResult = ( INT ) lOperand ;
return S_OK ;
}
# endif
//
// LONG_PTR -> INT32 conversion
//
# define LongPtrToInt32 LongPtrToInt
//
// LONG_PTR -> INT_PTR conversion
//
__inline
HRESULT
LongPtrToIntPtr (
__inn LONG_PTR lOperand ,
__outt __deref_out_range ( = = , lOperand ) INT_PTR * piResult )
{
C_ASSERT ( sizeof ( LONG_PTR ) = = sizeof ( INT_PTR ) ) ;
* piResult = ( INT_PTR ) lOperand ;
return S_OK ;
}
//
// LONG_PTR -> UINT conversion
//
# ifdef _WIN64
# define LongPtrToUInt LongLongToUInt
# else
__inline
HRESULT
LongPtrToUInt (
__inn LONG_PTR lOperand ,
__outt __deref_out_range ( = = , lOperand ) UINT * puResult )
{
HRESULT hr ;
if ( lOperand > = 0 )
{
* puResult = ( UINT ) lOperand ;
hr = S_OK ;
}
else
{
* puResult = UINT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
# endif
//
// LONG_PTR -> UINT32 conversion
//
# define LongPtrToUInt32 LongPtrToUInt
//
// LONG_PTR -> UINT_PTR conversion
//
__inline
HRESULT
LongPtrToUIntPtr (
__inn LONG_PTR lOperand ,
__outt __deref_out_range ( = = , lOperand ) UINT_PTR * puResult )
{
HRESULT hr ;
if ( lOperand > = 0 )
{
* puResult = ( UINT_PTR ) lOperand ;
hr = S_OK ;
}
else
{
* puResult = UINT_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONG_PTR -> LONG conversion
//
# ifdef _WIN64
# define LongPtrToLong LongLongToLong
# else
__inline
HRESULT
LongPtrToLong (
__inn LONG_PTR lOperand ,
__outt __deref_out_range ( = = , lOperand ) LONG * plResult )
{
* plResult = ( LONG ) lOperand ;
return S_OK ;
}
# endif
//
// LONG_PTR -> ULONG conversion
//
# ifdef _WIN64
# define LongPtrToULong LongLongToULong
# else
__inline
HRESULT
LongPtrToULong (
__inn LONG_PTR lOperand ,
__outt __deref_out_range ( = = , lOperand ) ULONG * pulResult )
{
HRESULT hr ;
if ( lOperand > = 0 )
{
* pulResult = ( ULONG ) lOperand ;
hr = S_OK ;
}
else
{
* pulResult = ULONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
# endif
//
// LONG_PTR -> ULONG_PTR conversion
//
__inline
HRESULT
LongPtrToULongPtr (
__inn LONG_PTR lOperand ,
__outt __deref_out_range ( = = , lOperand ) ULONG_PTR * pulResult )
{
HRESULT hr ;
if ( lOperand > = 0 )
{
* pulResult = ( ULONG_PTR ) lOperand ;
hr = S_OK ;
}
else
{
* pulResult = ULONG_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONG_PTR -> DWORD conversion
//
# define LongPtrToDWord LongPtrToULong
//
// LONG_PTR -> DWORD_PTR conversion
//
# define LongPtrToDWordPtr LongPtrToULongPtr
//
// LONG_PTR -> ULONGLONG conversion
//
__inline
HRESULT
LongPtrToULongLong (
__inn LONG_PTR lOperand ,
__outt __deref_out_range ( = = , lOperand ) ULONGLONG * pullResult )
{
HRESULT hr ;
if ( lOperand > = 0 )
{
* pullResult = ( ULONGLONG ) lOperand ;
hr = S_OK ;
}
else
{
* pullResult = ULONGLONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONG_PTR -> DWORDLONG conversion
//
# define LongPtrToDWordLong LongPtrToULongLong
//
// LONG_PTR -> ULONG64 conversion
//
# define LongPtrToULong64 LongPtrToULongLong
//
// LONG_PTR -> DWORD64 conversion
//
# define LongPtrToDWord64 LongPtrToULongLong
//
// LONG_PTR -> UINT64 conversion
//
# define LongPtrToUInt64 LongPtrToULongLong
//
// LONG_PTR -> size_t conversion
//
# define LongPtrToSizeT LongPtrToUIntPtr
//
// LONG_PTR -> SIZE_T conversion
//
# define LongPtrToSIZET LongPtrToULongPtr
//
// ULONG -> INT8 conversion
//
__inline
HRESULT
ULongToInt8 (
__inn ULONG ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) INT8 * pi8Result )
{
HRESULT hr ;
if ( ulOperand < = INT8_MAX )
{
* pi8Result = ( INT8 ) ulOperand ;
hr = S_OK ;
}
else
{
* pi8Result = INT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONG -> UCHAR conversion
//
__inline
HRESULT
ULongToUChar (
__inn ULONG ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) UCHAR * pch )
{
HRESULT hr ;
if ( ulOperand < = 255 )
{
* pch = ( UCHAR ) ulOperand ;
hr = S_OK ;
}
else
{
* pch = ' \0 ' ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONG -> CHAR conversion
//
__forceinline
HRESULT
ULongToChar (
__inn ULONG ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) CHAR * pch )
{
# ifdef _CHAR_UNSIGNED
return ULongToUChar ( ulOperand , ( UCHAR * ) pch ) ;
# else
return ULongToInt8 ( ulOperand , ( INT8 * ) pch ) ;
# endif
}
//
// ULONG -> UINT8 conversion
//
__inline
HRESULT
ULongToUInt8 (
__inn ULONG ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) UINT8 * pui8Result )
{
HRESULT hr ;
if ( ulOperand < = UINT8_MAX )
{
* pui8Result = ( UINT8 ) ulOperand ;
hr = S_OK ;
}
else
{
* pui8Result = UINT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONG -> BYTE conversion
//
# define ULongToByte ULongToUInt8
//
// ULONG -> SHORT conversion
//
__inline
HRESULT
ULongToShort (
__inn ULONG ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) SHORT * psResult )
{
HRESULT hr ;
if ( ulOperand < = SHORT_MAX )
{
* psResult = ( SHORT ) ulOperand ;
hr = S_OK ;
}
else
{
* psResult = SHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONG -> INT16 conversion
//
# define ULongToInt16 ULongToShort
//
// ULONG -> USHORT conversion
//
__inline
HRESULT
ULongToUShort (
__inn ULONG ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) USHORT * pusResult )
{
HRESULT hr ;
if ( ulOperand < = USHORT_MAX )
{
* pusResult = ( USHORT ) ulOperand ;
hr = S_OK ;
}
else
{
* pusResult = USHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONG -> UINT16 conversion
//
# define ULongToUInt16 ULongToUShort
//
// ULONG -> WORD conversion
//
# define ULongToWord ULongToUShort
//
// ULONG -> INT conversion
//
__inline
HRESULT
ULongToInt (
__inn ULONG ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) INT * piResult )
{
HRESULT hr ;
if ( ulOperand < = INT_MAX )
{
* piResult = ( INT ) ulOperand ;
hr = S_OK ;
}
else
{
* piResult = INT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONG -> INT32 conversion
//
# define ULongToInt32 ULongToInt
//
// ULONG -> INT_PTR conversion
//
# ifdef _WIN64
__inline
HRESULT
ULongToIntPtr (
__inn ULONG ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) INT_PTR * piResult )
{
* piResult = ( INT_PTR ) ulOperand ;
return S_OK ;
}
# else
# define ULongToIntPtr ULongToInt
# endif
//
// ULONG -> UINT conversion
//
__inline
HRESULT
ULongToUInt (
__inn ULONG ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) UINT * puResult )
{
//C_ASSERT(sizeof(ULONG) == sizeof(UINT));
* puResult = ( UINT ) ulOperand ;
return S_OK ;
}
//
// ULONG -> UINT32 conversion
//
# define ULongToUInt32 ULongToUInt
//
// ULONG -> UINT_PTR conversion
//
# ifdef _WIN64
__inline
HRESULT
ULongToUIntPtr (
__inn ULONG ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) UINT_PTR * puiResult )
{
C_ASSERT ( sizeof ( UINT_PTR ) > sizeof ( ULONG ) ) ;
* puiResult = ( UINT_PTR ) ulOperand ;
return S_OK ;
}
# else
# define ULongToUIntPtr ULongToUInt
# endif
//
// ULONG -> LONG conversion
//
__inline
HRESULT
ULongToLong (
__inn ULONG ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) LONG * plResult )
{
HRESULT hr ;
if ( ulOperand < = INT32_MAX )
{
* plResult = ( LONG ) ulOperand ;
hr = S_OK ;
}
else
{
* plResult = LONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONG -> LONG_PTR conversion
//
# ifdef _WIN64
__inline
HRESULT
ULongToLongPtr (
__inn ULONG ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) LONG_PTR * plResult )
{
C_ASSERT ( sizeof ( LONG_PTR ) > sizeof ( ULONG ) ) ;
* plResult = ( LONG_PTR ) ulOperand ;
return S_OK ;
}
# else
# define ULongToLongPtr ULongToLong
# endif
//
// ULONG -> ptrdiff_t conversion
//
# define ULongToPtrdiffT ULongToIntPtr
//
// ULONG -> SSIZE_T conversion
//
# define ULongToSSIZET ULongToLongPtr
//
// ULONG_PTR -> INT8 conversion
//
__inline
HRESULT
ULongPtrToInt8 (
__inn ULONG_PTR ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) INT8 * pi8Result )
{
HRESULT hr ;
if ( ulOperand < = INT8_MAX )
{
* pi8Result = ( INT8 ) ulOperand ;
hr = S_OK ;
}
else
{
* pi8Result = INT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONG_PTR -> UCHAR conversion
//
__inline
HRESULT
ULongPtrToUChar (
__inn ULONG_PTR ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) UCHAR * pch )
{
HRESULT hr ;
if ( ulOperand < = 255 )
{
* pch = ( UCHAR ) ulOperand ;
hr = S_OK ;
}
else
{
* pch = ' \0 ' ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONG_PTR -> CHAR conversion
//
__forceinline
HRESULT
ULongPtrToChar (
__inn ULONG_PTR ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) CHAR * pch )
{
# ifdef _CHAR_UNSIGNED
return ULongPtrToUChar ( ulOperand , ( UCHAR * ) pch ) ;
# else
return ULongPtrToInt8 ( ulOperand , ( INT8 * ) pch ) ;
# endif
}
//
// ULONG_PTR -> UINT8 conversion
//
__inline
HRESULT
ULongPtrToUInt8 (
__inn ULONG_PTR ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) UINT8 * pui8Result )
{
HRESULT hr ;
if ( ulOperand < = UINT8_MAX )
{
* pui8Result = ( UINT8 ) ulOperand ;
hr = S_OK ;
}
else
{
* pui8Result = UINT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONG_PTR -> BYTE conversion
//
# define ULongPtrToByte ULongPtrToUInt8
//
// ULONG_PTR -> SHORT conversion
//
__inline
HRESULT
ULongPtrToShort (
__inn ULONG_PTR ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) SHORT * psResult )
{
HRESULT hr ;
if ( ulOperand < = SHORT_MAX )
{
* psResult = ( SHORT ) ulOperand ;
hr = S_OK ;
}
else
{
* psResult = SHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONG_PTR -> INT16 conversion
//
# define ULongPtrToInt16 ULongPtrToShort
//
// ULONG_PTR -> USHORT conversion
//
__inline
HRESULT
ULongPtrToUShort (
__inn ULONG_PTR ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) USHORT * pusResult )
{
HRESULT hr ;
if ( ulOperand < = USHORT_MAX )
{
* pusResult = ( USHORT ) ulOperand ;
hr = S_OK ;
}
else
{
* pusResult = USHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONG_PTR -> UINT16 conversion
//
# define ULongPtrToUInt16 ULongPtrToUShort
//
// ULONG_PTR -> WORD conversion
//
# define ULongPtrToWord ULongPtrToUShort
//
// ULONG_PTR -> INT conversion
//
__inline
HRESULT
ULongPtrToInt (
__inn ULONG_PTR ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) INT * piResult )
{
HRESULT hr ;
if ( ulOperand < = INT_MAX )
{
* piResult = ( INT ) ulOperand ;
hr = S_OK ;
}
else
{
* piResult = INT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONG_PTR -> INT32 conversion
//
# define ULongPtrToInt32 ULongPtrToInt
//
// ULONG_PTR -> INT_PTR conversion
//
__inline
HRESULT
ULongPtrToIntPtr (
__inn ULONG_PTR ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) INT_PTR * piResult )
{
HRESULT hr ;
if ( ulOperand < = INT_PTR_MAX )
{
* piResult = ( INT_PTR ) ulOperand ;
hr = S_OK ;
}
else
{
* piResult = INT_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONG_PTR -> UINT conversion
//
# ifdef _WIN64
# define ULongPtrToUInt ULongLongToUInt
# else
__inline
HRESULT
ULongPtrToUInt (
__inn ULONG_PTR ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) UINT * puResult )
{
C_ASSERT ( sizeof ( ULONG_PTR ) = = sizeof ( UINT ) ) ;
* puResult = ( UINT ) ulOperand ;
return S_OK ;
}
# endif
//
// ULONG_PTR -> UINT32 conversion
//
# define ULongPtrToUInt32 ULongPtrToUInt
//
// ULONG_PTR -> UINT_PTR conversion
//
__inline
HRESULT
ULongPtrToUIntPtr (
__inn ULONG_PTR ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) UINT_PTR * puResult )
{
* puResult = ( UINT_PTR ) ulOperand ;
return S_OK ;
}
//
// ULONG_PTR -> LONG conversion
//
__inline
HRESULT
ULongPtrToLong (
__inn ULONG_PTR ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) LONG * plResult )
{
HRESULT hr ;
if ( ulOperand < = INT32_MAX )
{
* plResult = ( LONG ) ulOperand ;
hr = S_OK ;
}
else
{
* plResult = LONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONG_PTR -> LONG_PTR conversion
//
__inline
HRESULT
ULongPtrToLongPtr (
__inn ULONG_PTR ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) LONG_PTR * plResult )
{
HRESULT hr ;
if ( ulOperand < = LONG_PTR_MAX )
{
* plResult = ( LONG_PTR ) ulOperand ;
hr = S_OK ;
}
else
{
* plResult = LONG_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONG_PTR -> ULONG conversion
//
# ifdef _WIN64
# define ULongPtrToULong ULongLongToULong
# else
__inline
HRESULT
ULongPtrToULong (
__inn ULONG_PTR ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) ULONG * pulResult )
{
* pulResult = ( ULONG ) ulOperand ;
return S_OK ;
}
# endif
//
// ULONG_PTR -> DWORD conversion
//
# define ULongPtrToDWord ULongPtrToULong
//
// ULONG_PTR -> LONGLONG conversion
//
# ifdef _WIN64
# define ULongPtrToLongLong ULongLongToLongLong
# else
__inline
HRESULT
ULongPtrToLongLong (
__inn ULONG_PTR ulOperand ,
__outt __deref_out_range ( = = , ulOperand ) LONGLONG * pllResult )
{
* pllResult = ( LONGLONG ) ulOperand ;
return S_OK ;
}
# endif
//
// ULONG_PTR -> LONG64 conversion
//
# define ULongPtrToLong64 ULongPtrToLongLong
//
// ULONG_PTR -> INT64
//
# define ULongPtrToInt64 ULongPtrToLongLong
//
// ULONG_PTR -> ptrdiff_t conversion
//
# define ULongPtrToPtrdiffT ULongPtrToIntPtr
//
// ULONG_PTR -> SSIZE_T conversion
//
# define ULongPtrToSSIZET ULongPtrToLongPtr
//
// DWORD -> INT8 conversion
//
# define DWordToInt8 ULongToInt8
//
// DWORD -> CHAR conversion
//
# define DWordToChar ULongToChar
//
// DWORD -> UCHAR conversion
//
# define DWordToUChar ULongToUChar
//
// DWORD -> UINT8 conversion
//
# define DWordToUInt8 ULongToUInt8
//
// DWORD -> BYTE conversion
//
# define DWordToByte ULongToUInt8
//
// DWORD -> SHORT conversion
//
# define DWordToShort ULongToShort
//
// DWORD -> INT16 conversion
//
# define DWordToInt16 ULongToShort
//
// DWORD -> USHORT conversion
//
# define DWordToUShort ULongToUShort
//
// DWORD -> UINT16 conversion
//
# define DWordToUInt16 ULongToUShort
//
// DWORD -> WORD conversion
//
# define DWordToWord ULongToUShort
//
// DWORD -> INT conversion
//
# define DWordToInt ULongToInt
//
// DWORD -> INT32 conversion
//
# define DWordToInt32 ULongToInt
//
// DWORD -> INT_PTR conversion
//
# define DWordToIntPtr ULongToIntPtr
//
// DWORD -> UINT conversion
//
# define DWordToUInt ULongToUInt
//
// DWORD -> UINT32 conversion
//
# define DWordToUInt32 ULongToUInt
//
// DWORD -> UINT_PTR conversion
//
# define DWordToUIntPtr ULongToUIntPtr
//
// DWORD -> LONG conversion
//
# define DWordToLong ULongToLong
//
// DWORD -> LONG_PTR conversion
//
# define DWordToLongPtr ULongToLongPtr
//
// DWORD -> ptrdiff_t conversion
//
# define DWordToPtrdiffT ULongToIntPtr
//
// DWORD -> SSIZE_T conversion
//
# define DWordToSSIZET ULongToLongPtr
//
// DWORD_PTR -> INT8 conversion
//
# define DWordPtrToInt8 ULongPtrToInt8
//
// DWORD_PTR -> UCHAR conversion
//
# define DWordPtrToUChar ULongPtrToUChar
//
// DWORD_PTR -> CHAR conversion
//
# define DWordPtrToChar ULongPtrToChar
//
// DWORD_PTR -> UINT8 conversion
//
# define DWordPtrToUInt8 ULongPtrToUInt8
//
// DWORD_PTR -> BYTE conversion
//
# define DWordPtrToByte ULongPtrToUInt8
//
// DWORD_PTR -> SHORT conversion
//
# define DWordPtrToShort ULongPtrToShort
//
// DWORD_PTR -> INT16 conversion
//
# define DWordPtrToInt16 ULongPtrToShort
//
// DWORD_PTR -> USHORT conversion
//
# define DWordPtrToUShort ULongPtrToUShort
//
// DWORD_PTR -> UINT16 conversion
//
# define DWordPtrToUInt16 ULongPtrToUShort
//
// DWORD_PTR -> WORD conversion
//
# define DWordPtrToWord ULongPtrToUShort
//
// DWORD_PTR -> INT conversion
//
# define DWordPtrToInt ULongPtrToInt
//
// DWORD_PTR -> INT32 conversion
//
# define DWordPtrToInt32 ULongPtrToInt
//
// DWORD_PTR -> INT_PTR conversion
//
# define DWordPtrToIntPtr ULongPtrToIntPtr
//
// DWORD_PTR -> UINT conversion
//
# define DWordPtrToUInt ULongPtrToUInt
//
// DWORD_PTR -> UINT32 conversion
//
# define DWordPtrToUInt32 ULongPtrToUInt
//
// DWODR_PTR -> UINT_PTR conversion
//
# define DWordPtrToUIntPtr ULongPtrToUIntPtr
//
// DWORD_PTR -> LONG conversion
//
# define DWordPtrToLong ULongPtrToLong
//
// DWORD_PTR -> LONG_PTR conversion
//
# define DWordPtrToLongPtr ULongPtrToLongPtr
//
// DWORD_PTR -> ULONG conversion
//
# define DWordPtrToULong ULongPtrToULong
//
// DWORD_PTR -> DWORD conversion
//
# define DWordPtrToDWord ULongPtrToULong
//
// DWORD_PTR -> LONGLONG conversion
//
# define DWordPtrToLongLong ULongPtrToLongLong
//
// DWORD_PTR -> LONG64 conversion
//
# define DWordPtrToLong64 ULongPtrToLongLong
//
// DWORD_PTR -> INT64 conversion
//
# define DWordPtrToInt64 ULongPtrToLongLong
//
// DWORD_PTR -> ptrdiff_t conversion
//
# define DWordPtrToPtrdiffT ULongPtrToIntPtr
//
// DWORD_PTR -> SSIZE_T conversion
//
# define DWordPtrToSSIZET ULongPtrToLongPtr
//
// LONGLONG -> INT8 conversion
//
__inline
HRESULT
LongLongToInt8 (
__inn LONGLONG llOperand ,
__outt __deref_out_range ( = = , llOperand ) INT8 * pi8Result )
{
HRESULT hr ;
if ( ( llOperand > = INT8_MIN ) & & ( llOperand < = INT8_MAX ) )
{
* pi8Result = ( INT8 ) llOperand ;
hr = S_OK ;
}
else
{
* pi8Result = INT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONGLONG -> UCHAR conversion
//
__inline
HRESULT
LongLongToUChar (
__inn LONGLONG llOperand ,
__outt __deref_out_range ( = = , llOperand ) UCHAR * pch )
{
HRESULT hr ;
if ( ( llOperand > = 0 ) & & ( llOperand < = 255 ) )
{
* pch = ( UCHAR ) llOperand ;
hr = S_OK ;
}
else
{
* pch = ' \0 ' ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONGLONG -> CHAR conversion
//
__forceinline
HRESULT
LongLongToChar (
__inn LONGLONG llOperand ,
__outt __deref_out_range ( = = , llOperand ) CHAR * pch )
{
# ifdef _CHAR_UNSIGNED
return LongLongToUChar ( llOperand , ( UCHAR * ) pch ) ;
# else
return LongLongToInt8 ( llOperand , ( INT8 * ) pch ) ;
# endif
}
//
// LONGLONG -> UINT8 conversion
//
__inline
HRESULT
LongLongToUInt8 (
__inn LONGLONG llOperand ,
__outt __deref_out_range ( = = , llOperand ) UINT8 * pu8Result )
{
HRESULT hr ;
if ( ( llOperand > = 0 ) & & ( llOperand < = UINT8_MAX ) )
{
* pu8Result = ( UINT8 ) llOperand ;
hr = S_OK ;
}
else
{
* pu8Result = UINT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONGLONG -> BYTE conversion
//
# define LongLongToByte LongLongToUInt8
//
// LONGLONG -> SHORT conversion
//
__inline
HRESULT
LongLongToShort (
__inn LONGLONG llOperand ,
__outt __deref_out_range ( = = , llOperand ) SHORT * psResult )
{
HRESULT hr ;
if ( ( llOperand > = SHORT_MIN ) & & ( llOperand < = SHORT_MAX ) )
{
* psResult = ( SHORT ) llOperand ;
hr = S_OK ;
}
else
{
* psResult = SHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONGLONG -> INT16 conversion
//
# define LongLongToInt16 LongLongToShort
//
// LONGLONG -> USHORT conversion
//
__inline
HRESULT
LongLongToUShort (
__inn LONGLONG llOperand ,
__outt __deref_out_range ( = = , llOperand ) USHORT * pusResult )
{
HRESULT hr ;
if ( ( llOperand > = 0 ) & & ( llOperand < = USHORT_MAX ) )
{
* pusResult = ( USHORT ) llOperand ;
hr = S_OK ;
}
else
{
* pusResult = USHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONGLONG -> UINT16 conversion
//
# define LongLongToUInt16 LongLongToUShort
//
// LONGLONG -> WORD conversion
//
# define LongLongToWord LongLongToUShort
//
// LONGLONG -> INT conversion
//
__inline
HRESULT
LongLongToInt (
__inn LONGLONG llOperand ,
__outt __deref_out_range ( = = , llOperand ) INT * piResult )
{
HRESULT hr ;
if ( ( llOperand > = INT_MIN ) & & ( llOperand < = INT_MAX ) )
{
* piResult = ( INT ) llOperand ;
hr = S_OK ;
}
else
{
* piResult = INT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONGLONG -> INT32 conversion
//
# define LongLongToInt32 LongLongToInt
//
// LONGLONG -> INT_PTR conversion
//
# ifdef _WIN64
__inline
HRESULT
LongLongToIntPtr (
__inn LONGLONG llOperand ,
__outt __deref_out_range ( = = , llOperand ) INT_PTR * piResult )
{
* piResult = llOperand ;
return S_OK ;
}
# else
# define LongLongToIntPtr LongLongToInt
# endif
//
// LONGLONG -> UINT conversion
//
__inline
HRESULT
LongLongToUInt (
__inn LONGLONG llOperand ,
__outt __deref_out_range ( = = , llOperand ) UINT * puResult )
{
HRESULT hr ;
if ( ( llOperand > = 0 ) & & ( llOperand < = UINT_MAX ) )
{
* puResult = ( UINT ) llOperand ;
hr = S_OK ;
}
else
{
* puResult = UINT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONGLONG -> UINT32 conversion
//
# define LongLongToUInt32 LongLongToUInt
//
// LONGLONG -> UINT_PTR conversion
//
# ifdef _WIN64
# define LongLongToUIntPtr LongLongToULongLong
# else
# define LongLongToUIntPtr LongLongToUInt
# endif
//
// LONGLONG -> LONG conversion
//
__inline
HRESULT
LongLongToLong (
__inn LONGLONG llOperand ,
__outt __deref_out_range ( = = , llOperand ) LONG * plResult )
{
HRESULT hr ;
if ( ( llOperand > = INT32_MIN ) & & ( llOperand < = INT32_MAX ) )
{
* plResult = ( LONG ) llOperand ;
hr = S_OK ;
}
else
{
* plResult = LONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONGLONG -> LONG_PTR conversion
//
# ifdef _WIN64
__inline
HRESULT
LongLongToLongPtr (
__inn LONGLONG llOperand ,
__outt __deref_out_range ( = = , llOperand ) LONG_PTR * plResult )
{
* plResult = ( LONG_PTR ) llOperand ;
return S_OK ;
}
# else
# define LongLongToLongPtr LongLongToLong
# endif
//
// LONGLONG -> ULONG conversion
//
__inline
HRESULT
LongLongToULong (
__inn LONGLONG llOperand ,
__outt __deref_out_range ( = = , llOperand ) ULONG * pulResult )
{
HRESULT hr ;
if ( ( llOperand > = 0 ) & & ( llOperand < = ( LONGLONG ) ( ULONGLONG ) UINT32_MAX ) )
{
* pulResult = ( ULONG ) llOperand ;
hr = S_OK ;
}
else
{
* pulResult = ULONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONGLONG -> ULONG_PTR conversion
//
# ifdef _WIN64
# define LongLongToULongPtr LongLongToULongLong
# else
# define LongLongToULongPtr LongLongToULong
# endif
//
// LONGLONG -> DWORD conversion
//
# define LongLongToDWord LongLongToULong
//
// LONGLONG -> DWORD_PTR conversion
//
# define LongLongToDWordPtr LongLongToULongPtr
//
// LONGLONG -> ULONGLONG conversion
//
__inline
HRESULT
LongLongToULongLong (
__inn LONGLONG llOperand ,
__outt __deref_out_range ( = = , llOperand ) ULONGLONG * pullResult )
{
HRESULT hr ;
if ( llOperand > = 0 )
{
* pullResult = ( ULONGLONG ) llOperand ;
hr = S_OK ;
}
else
{
* pullResult = ULONGLONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// LONGLONG -> DWORDLONG conversion
//
# define LongLongToDWordLong LongLongToULongLong
//
// LONGLONG -> ULONG64 conversion
//
# define LongLongToULong64 LongLongToULongLong
//
// LONGLONG -> DWORD64 conversion
//
# define LongLongToDWord64 LongLongToULongLong
//
// LONGLONG -> UINT64 conversion
//
# define LongLongToUInt64 LongLongToULongLong
//
// LONGLONG -> ptrdiff_t conversion
//
# define LongLongToPtrdiffT LongLongToIntPtr
//
// LONGLONG -> size_t conversion
//
# define LongLongToSizeT LongLongToUIntPtr
//
// LONGLONG -> SSIZE_T conversion
//
# define LongLongToSSIZET LongLongToLongPtr
//
// LONGLONG -> SIZE_T conversion
//
# define LongLongToSIZET LongLongToULongPtr
//
// LONG64 -> CHAR conversion
//
# define Long64ToChar LongLongToChar
//
// LONG64 -> INT8 conversion
//
# define Long64ToInt8 LongLongToInt8
//
// LONG64 -> UCHAR conversion
//
# define Long64ToUChar LongLongToUChar
//
// LONG64 -> UINT8 conversion
//
# define Long64ToUInt8 LongLongToUInt8
//
// LONG64 -> BYTE conversion
//
# define Long64ToByte LongLongToUInt8
//
// LONG64 -> SHORT conversion
//
# define Long64ToShort LongLongToShort
//
// LONG64 -> INT16 conversion
//
# define Long64ToInt16 LongLongToShort
//
// LONG64 -> USHORT conversion
//
# define Long64ToUShort LongLongToUShort
//
// LONG64 -> UINT16 conversion
//
# define Long64ToUInt16 LongLongToUShort
//
// LONG64 -> WORD conversion
//
# define Long64ToWord LongLongToUShort
//
// LONG64 -> INT conversion
//
# define Long64ToInt LongLongToInt
//
// LONG64 -> INT32 conversion
//
# define Long64ToInt32 LongLongToInt
//
// LONG64 -> INT_PTR conversion
//
# define Long64ToIntPtr LongLongToIntPtr
//
// LONG64 -> UINT conversion
//
# define Long64ToUInt LongLongToUInt
//
// LONG64 -> UINT32 conversion
//
# define Long64ToUInt32 LongLongToUInt
//
// LONG64 -> UINT_PTR conversion
//
# define Long64ToUIntPtr LongLongToUIntPtr
//
// LONG64 -> LONG conversion
//
# define Long64ToLong LongLongToLong
//
// LONG64 -> LONG_PTR conversion
//
# define Long64ToLongPtr LongLongToLongPtr
//
// LONG64 -> ULONG conversion
//
# define Long64ToULong LongLongToULong
//
// LONG64 -> ULONG_PTR conversion
//
# define Long64ToULongPtr LongLongToULongPtr
//
// LONG64 -> DWORD conversion
//
# define Long64ToDWord LongLongToULong
//
// LONG64 -> DWORD_PTR conversion
//
# define Long64ToDWordPtr LongLongToULongPtr
//
// LONG64 -> ULONGLONG conversion
//
# define Long64ToULongLong LongLongToULongLong
//
// LONG64 -> ptrdiff_t conversion
//
# define Long64ToPtrdiffT LongLongToIntPtr
//
// LONG64 -> size_t conversion
//
# define Long64ToSizeT LongLongToUIntPtr
//
// LONG64 -> SSIZE_T conversion
//
# define Long64ToSSIZET LongLongToLongPtr
//
// LONG64 -> SIZE_T conversion
//
# define Long64ToSIZET LongLongToULongPtr
//
// INT64 -> CHAR conversion
//
# define Int64ToChar LongLongToChar
//
// INT64 -> INT8 conversion
//
# define Int64ToInt8 LongLongToInt8
//
// INT64 -> UCHAR conversion
//
# define Int64ToUChar LongLongToUChar
//
// INT64 -> UINT8 conversion
//
# define Int64ToUInt8 LongLongToUInt8
//
// INT64 -> BYTE conversion
//
# define Int64ToByte LongLongToUInt8
//
// INT64 -> SHORT conversion
//
# define Int64ToShort LongLongToShort
//
// INT64 -> INT16 conversion
//
# define Int64ToInt16 LongLongToShort
//
// INT64 -> USHORT conversion
//
# define Int64ToUShort LongLongToUShort
//
// INT64 -> UINT16 conversion
//
# define Int64ToUInt16 LongLongToUShort
//
// INT64 -> WORD conversion
//
# define Int64ToWord LongLongToUShort
//
// INT64 -> INT conversion
//
# define Int64ToInt LongLongToInt
//
// INT64 -> INT32 conversion
//
# define Int64ToInt32 LongLongToInt
//
// INT64 -> INT_PTR conversion
//
# define Int64ToIntPtr LongLongToIntPtr
//
// INT64 -> UINT conversion
//
# define Int64ToUInt LongLongToUInt
//
// INT64 -> UINT32 conversion
//
# define Int64ToUInt32 LongLongToUInt
//
// INT64 -> UINT_PTR conversion
//
# define Int64ToUIntPtr LongLongToUIntPtr
//
// INT64 -> LONG conversion
//
# define Int64ToLong LongLongToLong
//
// INT64 -> LONG_PTR conversion
//
# define Int64ToLongPtr LongLongToLongPtr
//
// INT64 -> ULONG conversion
//
# define Int64ToULong LongLongToULong
//
// INT64 -> ULONG_PTR conversion
//
# define Int64ToULongPtr LongLongToULongPtr
//
// INT64 -> DWORD conversion
//
# define Int64ToDWord LongLongToULong
//
// INT64 -> DWORD_PTR conversion
//
# define Int64ToDWordPtr LongLongToULongPtr
//
// INT64 -> ULONGLONG conversion
//
# define Int64ToULongLong LongLongToULongLong
//
// INT64 -> DWORDLONG conversion
//
# define Int64ToDWordLong LongLongToULongLong
//
// INT64 -> ULONG64 conversion
//
# define Int64ToULong64 LongLongToULongLong
//
// INT64 -> DWORD64 conversion
//
# define Int64ToDWord64 LongLongToULongLong
//
// INT64 -> UINT64 conversion
//
# define Int64ToUInt64 LongLongToULongLong
//
// INT64 -> ptrdiff_t conversion
//
# define Int64ToPtrdiffT LongLongToIntPtr
//
// INT64 -> size_t conversion
//
# define Int64ToSizeT LongLongToUIntPtr
//
// INT64 -> SSIZE_T conversion
//
# define Int64ToSSIZET LongLongToLongPtr
//
// INT64 -> SIZE_T conversion
//
# define Int64ToSIZET LongLongToULongPtr
//
// ULONGLONG -> INT8 conversion
//
__inline
HRESULT
ULongLongToInt8 (
__inn ULONGLONG ullOperand ,
__outt __deref_out_range ( = = , ullOperand ) INT8 * pi8Result )
{
HRESULT hr ;
if ( ullOperand < = INT8_MAX )
{
* pi8Result = ( INT8 ) ullOperand ;
hr = S_OK ;
}
else
{
* pi8Result = INT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONGLONG -> UCHAR conversion
//
__inline
HRESULT
ULongLongToUChar (
__inn ULONGLONG ullOperand ,
__outt __deref_out_range ( = = , ullOperand ) UCHAR * pch )
{
HRESULT hr ;
if ( ullOperand < = 255 )
{
* pch = ( UCHAR ) ullOperand ;
hr = S_OK ;
}
else
{
* pch = ' \0 ' ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONGLONG -> CHAR conversion
//
__forceinline
HRESULT
ULongLongToChar (
__inn ULONGLONG ullOperand ,
__outt __deref_out_range ( = = , ullOperand ) CHAR * pch )
{
# ifdef _CHAR_UNSIGNED
return ULongLongToUChar ( ullOperand , ( UCHAR * ) pch ) ;
# else
return ULongLongToInt8 ( ullOperand , ( INT8 * ) pch ) ;
# endif
}
//
// ULONGLONG -> UINT8 conversion
//
__inline
HRESULT
ULongLongToUInt8 (
__inn ULONGLONG ullOperand ,
__outt __deref_out_range ( = = , ullOperand ) UINT8 * pu8Result )
{
HRESULT hr ;
if ( ullOperand < = UINT8_MAX )
{
* pu8Result = ( UINT8 ) ullOperand ;
hr = S_OK ;
}
else
{
* pu8Result = UINT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONGLONG -> BYTE conversion
//
# define ULongLongToByte ULongLongToUInt8
//
// ULONGLONG -> SHORT conversion
//
__inline
HRESULT
ULongLongToShort (
__inn ULONGLONG ullOperand ,
__outt __deref_out_range ( = = , ullOperand ) SHORT * psResult )
{
HRESULT hr ;
if ( ullOperand < = SHORT_MAX )
{
* psResult = ( SHORT ) ullOperand ;
hr = S_OK ;
}
else
{
* psResult = SHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONGLONG -> INT16 conversion
//
# define ULongLongToInt16 ULongLongToShort
//
// ULONGLONG -> USHORT conversion
//
__inline
HRESULT
ULongLongToUShort (
__inn ULONGLONG ullOperand ,
__outt __deref_out_range ( = = , ullOperand ) USHORT * pusResult )
{
HRESULT hr ;
if ( ullOperand < = USHORT_MAX )
{
* pusResult = ( USHORT ) ullOperand ;
hr = S_OK ;
}
else
{
* pusResult = USHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONGLONG -> UINT16 conversion
//
# define ULongLongToUInt16 ULongLongToUShort
//
// ULONGLONG -> WORD conversion
//
# define ULongLongToWord ULongLongToUShort
//
// ULONGLONG -> INT conversion
//
__inline
HRESULT
ULongLongToInt (
__inn ULONGLONG ullOperand ,
__outt __deref_out_range ( = = , ullOperand ) INT * piResult )
{
HRESULT hr ;
if ( ullOperand < = INT_MAX )
{
* piResult = ( INT ) ullOperand ;
hr = S_OK ;
}
else
{
* piResult = INT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONGLONG -> INT32 conversion
//
# define ULongLongToInt32 ULongLongToInt
//
// ULONGLONG -> INT_PTR conversion
//
# ifdef _WIN64
# define ULongLongToIntPtr ULongLongToLongLong
# else
# define ULongLongToIntPtr ULongLongToInt
# endif
//
// ULONGLONG -> UINT conversion
//
__inline
HRESULT
ULongLongToUInt (
__inn ULONGLONG ullOperand ,
__outt __deref_out_range ( = = , ullOperand ) UINT * puResult )
{
HRESULT hr ;
if ( ullOperand < = UINT_MAX )
{
* puResult = ( UINT ) ullOperand ;
hr = S_OK ;
}
else
{
* puResult = UINT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONGLONG -> UINT32 conversion
//
# define ULongLongToUInt32 ULongLongToUInt
//
// ULONGLONG -> UINT_PTR conversion
//
# ifdef _WIN64
__inline
HRESULT
ULongLongToUIntPtr (
__inn ULONGLONG ullOperand ,
__outt __deref_out_range ( = = , ullOperand ) UINT_PTR * puResult )
{
* puResult = ullOperand ;
return S_OK ;
}
# else
# define ULongLongToUIntPtr ULongLongToUInt
# endif
//
// ULONGLONG -> LONG conversion
//
__inline
HRESULT
ULongLongToLong (
__inn ULONGLONG ullOperand ,
__outt __deref_out_range ( = = , ullOperand ) LONG * plResult )
{
HRESULT hr ;
if ( ullOperand < = INT32_MAX )
{
* plResult = ( LONG ) ullOperand ;
hr = S_OK ;
}
else
{
* plResult = LONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONGLONG -> LONG_PTR conversion
//
__inline
HRESULT
ULongLongToLongPtr (
__inn ULONGLONG ullOperand ,
__outt __deref_out_range ( = = , ullOperand ) LONG_PTR * plResult )
{
HRESULT hr ;
if ( ullOperand < = LONG_PTR_MAX )
{
* plResult = ( LONG_PTR ) ullOperand ;
hr = S_OK ;
}
else
{
* plResult = LONG_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONGLONG -> ULONG conversion
//
__inline
HRESULT
ULongLongToULong (
__inn ULONGLONG ullOperand ,
__outt __deref_out_range ( = = , ullOperand ) ULONG * pulResult )
{
HRESULT hr ;
if ( ullOperand < = UINT32_MAX )
{
* pulResult = ( ULONG ) ullOperand ;
hr = S_OK ;
}
else
{
* pulResult = ULONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONGLONG -> ULONG_PTR conversion
//
# ifdef _WIN64
__inline
HRESULT
ULongLongToULongPtr (
__inn ULONGLONG ullOperand ,
__outt __deref_out_range ( = = , ullOperand ) ULONG_PTR * pulResult )
{
* pulResult = ullOperand ;
return S_OK ;
}
# else
# define ULongLongToULongPtr ULongLongToULong
# endif
//
// ULONGLONG -> DWORD conversion
//
# define ULongLongToDWord ULongLongToULong
//
// ULONGLONG -> DWORD_PTR conversion
//
# define ULongLongToDWordPtr ULongLongToULongPtr
//
// ULONGLONG -> LONGLONG conversion
//
__inline
HRESULT
ULongLongToLongLong (
__inn ULONGLONG ullOperand ,
__outt __deref_out_range ( = = , ullOperand ) LONGLONG * pllResult )
{
HRESULT hr ;
if ( ullOperand < = LONGLONG_MAX )
{
* pllResult = ( LONGLONG ) ullOperand ;
hr = S_OK ;
}
else
{
* pllResult = LONGLONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONGLONG -> INT64 conversion
//
# define ULongLongToInt64 ULongLongToLongLong
//
// ULONGLONG -> LONG64 conversion
//
# define ULongLongToLong64 ULongLongToLongLong
//
// ULONGLONG -> ptrdiff_t conversion
//
# define ULongLongToPtrdiffT ULongLongToIntPtr
//
// ULONGLONG -> size_t conversion
//
# define ULongLongToSizeT ULongLongToUIntPtr
//
// ULONGLONG -> SSIZE_T conversion
//
# define ULongLongToSSIZET ULongLongToLongPtr
//
// ULONGLONG -> SIZE_T conversion
//
# define ULongLongToSIZET ULongLongToULongPtr
//
// DWORDLONG -> CHAR conversion
//
# define DWordLongToChar ULongLongToChar
//
// DWORDLONG -> INT8 conversion
//
# define DWordLongToInt8 ULongLongToInt8
//
// DWORDLONG -> UCHAR conversion
//
# define DWordLongToUChar ULongLongToUChar
//
// DWORDLONG -> UINT8 conversion
//
# define DWordLongToUInt8 ULongLongToUInt8
//
// DWORDLONG -> BYTE conversion
//
# define DWordLongToByte ULongLongToUInt8
//
// DWORDLONG -> SHORT conversion
//
# define DWordLongToShort ULongLongToShort
//
// DWORDLONG -> INT16 conversion
//
# define DWordLongToInt16 ULongLongToShort
//
// DWORDLONG -> USHORT conversion
//
# define DWordLongToUShort ULongLongToUShort
//
// DWORDLONG -> UINT16 conversion
//
# define DWordLongToUInt16 ULongLongToUShort
//
// DWORDLONG -> WORD conversion
//
# define DWordLongToWord ULongLongToUShort
//
// DWORDLONG -> INT conversion
//
# define DWordLongToInt ULongLongToInt
//
// DWORDLONG -> INT32 conversion
//
# define DWordLongToInt32 ULongLongToInt
//
// DWORDLONG -> INT_PTR conversion
//
# define DWordLongToIntPtr ULongLongToIntPtr
//
// DWORDLONG -> UINT conversion
//
# define DWordLongToUInt ULongLongToUInt
//
// DWORDLONG -> UINT32 conversion
//
# define DWordLongToUInt32 ULongLongToUInt
//
// DWORDLONG -> UINT_PTR conversion
//
# define DWordLongToUIntPtr ULongLongToUIntPtr
//
// DWORDLONG -> LONG conversion
//
# define DWordLongToLong ULongLongToLong
//
// DWORDLONG -> LONG_PTR conversion
//
# define DWordLongToLongPtr ULongLongToLongPtr
//
// DWORDLONG -> ULONG conversion
//
# define DWordLongToULong ULongLongToULong
//
// DWORDLONG -> ULONG_PTR conversion
//
# define DWordLongToULongPtr ULongLongToULongPtr
//
// DWORDLONG -> DWORD conversion
//
# define DWordLongToDWord ULongLongToULong
//
// DWORDLONG -> DWORD_PTR conversion
//
# define DWordLongToDWordPtr ULongLongToULongPtr
//
// DWORDLONG -> LONGLONG conversion
//
# define DWordLongToLongLong ULongLongToLongLong
//
// DWORDLONG -> LONG64 conversion
//
# define DWordLongToLong64 ULongLongToLongLong
//
// DWORDLONG -> INT64 conversion
//
# define DWordLongToInt64 ULongLongToLongLong
//
// DWORDLONG -> ptrdiff_t conversion
//
# define DWordLongToPtrdiffT ULongLongToIntPtr
//
// DWORDLONG -> size_t conversion
//
# define DWordLongToSizeT ULongLongToUIntPtr
//
// DWORDLONG -> SSIZE_T conversion
//
# define DWordLongToSSIZET ULongLongToLongPtr
//
// DWORDLONG -> SIZE_T conversion
//
# define DWordLongToSIZET ULongLongToULongPtr
//
// ULONG64 -> CHAR conversion
//
# define ULong64ToChar ULongLongToChar
//
// ULONG64 -> INT8 conversion
//
# define ULong64ToInt8 ULongLongToInt8
//
// ULONG64 -> UCHAR conversion
//
# define ULong64ToUChar ULongLongToUChar
//
// ULONG64 -> UINT8 conversion
//
# define ULong64ToUInt8 ULongLongToUInt8
//
// ULONG64 -> BYTE conversion
//
# define ULong64ToByte ULongLongToUInt8
//
// ULONG64 -> SHORT conversion
//
# define ULong64ToShort ULongLongToShort
//
// ULONG64 -> INT16 conversion
//
# define ULong64ToInt16 ULongLongToShort
//
// ULONG64 -> USHORT conversion
//
# define ULong64ToUShort ULongLongToUShort
//
// ULONG64 -> UINT16 conversion
//
# define ULong64ToUInt16 ULongLongToUShort
//
// ULONG64 -> WORD conversion
//
# define ULong64ToWord ULongLongToUShort
//
// ULONG64 -> INT conversion
//
# define ULong64ToInt ULongLongToInt
//
// ULONG64 -> INT32 conversion
//
# define ULong64ToInt32 ULongLongToInt
//
// ULONG64 -> INT_PTR conversion
//
# define ULong64ToIntPtr ULongLongToIntPtr
//
// ULONG64 -> UINT conversion
//
# define ULong64ToUInt ULongLongToUInt
//
// ULONG64 -> UINT32 conversion
//
# define ULong64ToUInt32 ULongLongToUInt
//
// ULONG64 -> UINT_PTR conversion
//
# define ULong64ToUIntPtr ULongLongToUIntPtr
//
// ULONG64 -> LONG conversion
//
# define ULong64ToLong ULongLongToLong
//
// ULONG64 -> LONG_PTR conversion
//
# define ULong64ToLongPtr ULongLongToLongPtr
//
// ULONG64 -> ULONG conversion
//
# define ULong64ToULong ULongLongToULong
//
// ULONG64 -> ULONG_PTR conversion
//
# define ULong64ToULongPtr ULongLongToULongPtr
//
// ULONG64 -> DWORD conversion
//
# define ULong64ToDWord ULongLongToULong
//
// ULONG64 -> DWORD_PTR conversion
//
# define ULong64ToDWordPtr ULongLongToULongPtr
//
// ULONG64 -> LONGLONG conversion
//
# define ULong64ToLongLong ULongLongToLongLong
//
// ULONG64 -> LONG64 conversion
//
# define ULong64ToLong64 ULongLongToLongLong
//
// ULONG64 -> INT64 conversion
//
# define ULong64ToInt64 ULongLongToLongLong
//
// ULONG64 -> ptrdiff_t conversion
//
# define ULong64ToPtrdiffT ULongLongToIntPtr
//
// ULONG64 -> size_t conversion
//
# define ULong64ToSizeT ULongLongToUIntPtr
//
// ULONG64 -> SSIZE_T conversion
//
# define ULong64ToSSIZET ULongLongToLongPtr
//
// ULONG64 -> SIZE_T conversion
//
# define ULong64ToSIZET ULongLongToULongPtr
//
// DWORD64 -> CHAR conversion
//
# define DWord64ToChar ULongLongToChar
//
// DWORD64 -> INT8 conversion
//
# define DWord64ToInt8 ULongLongToInt8
//
// DWORD64 -> UCHAR conversion
//
# define DWord64ToUChar ULongLongToUChar
//
// DWORD64 -> UINT8 conversion
//
# define DWord64ToUInt8 ULongLongToUInt8
//
// DWORD64 -> BYTE conversion
//
# define DWord64ToByte ULongLongToUInt8
//
// DWORD64 -> SHORT conversion
//
# define DWord64ToShort ULongLongToShort
//
// DWORD64 -> INT16 conversion
//
# define DWord64ToInt16 ULongLongToShort
//
// DWORD64 -> USHORT conversion
//
# define DWord64ToUShort ULongLongToUShort
//
// DWORD64 -> UINT16 conversion
//
# define DWord64ToUInt16 ULongLongToUShort
//
// DWORD64 -> WORD conversion
//
# define DWord64ToWord ULongLongToUShort
//
// DWORD64 -> INT conversion
//
# define DWord64ToInt ULongLongToInt
//
// DWORD64 -> INT32 conversion
//
# define DWord64ToInt32 ULongLongToInt
//
// DWORD64 -> INT_PTR conversion
//
# define DWord64ToIntPtr ULongLongToIntPtr
//
// DWORD64 -> UINT conversion
//
# define DWord64ToUInt ULongLongToUInt
//
// DWORD64 -> UINT32 conversion
//
# define DWord64ToUInt32 ULongLongToUInt
//
// DWORD64 -> UINT_PTR conversion
//
# define DWord64ToUIntPtr ULongLongToUIntPtr
//
// DWORD64 -> LONG conversion
//
# define DWord64ToLong ULongLongToLong
//
// DWORD64 -> LONG_PTR conversion
//
# define DWord64ToLongPtr ULongLongToLongPtr
//
// DWORD64 -> ULONG conversion
//
# define DWord64ToULong ULongLongToULong
//
// DWORD64 -> ULONG_PTR conversion
//
# define DWord64ToULongPtr ULongLongToULongPtr
//
// DWORD64 -> DWORD conversion
//
# define DWord64ToDWord ULongLongToULong
//
// DWORD64 -> DWORD_PTR conversion
//
# define DWord64ToDWordPtr ULongLongToULongPtr
//
// DWORD64 -> LONGLONG conversion
//
# define DWord64ToLongLong ULongLongToLongLong
//
// DWORD64 -> LONG64 conversion
//
# define DWord64ToLong64 ULongLongToLongLong
//
// DWORD64 -> INT64 conversion
//
# define DWord64ToInt64 ULongLongToLongLong
//
// DWORD64 -> ptrdiff_t conversion
//
# define DWord64ToPtrdiffT ULongLongToIntPtr
//
// DWORD64 -> size_t conversion
//
# define DWord64ToSizeT ULongLongToUIntPtr
//
// DWORD64 -> SSIZE_T conversion
//
# define DWord64ToSSIZET ULongLongToLongPtr
//
// DWORD64 -> SIZE_T conversion
//
# define DWord64ToSIZET ULongLongToULongPtr
//
// UINT64 -> CHAR conversion
//
# define UInt64ToChar ULongLongToChar
//
// UINT64 -> INT8 conversion
//
# define UInt64ToInt8 ULongLongToInt8
//
// UINT64 -> UCHAR conversion
//
# define UInt64ToUChar ULongLongToUChar
//
// UINT64 -> UINT8 conversion
//
# define UInt64ToUInt8 ULongLongToUInt8
//
// UINT64 -> BYTE conversion
//
# define UInt64ToByte ULongLongToUInt8
//
// UINT64 -> SHORT conversion
//
# define UInt64ToShort ULongLongToShort
//
// UINT64 -> INT16 conversion
//
//
# define UInt64ToInt16 ULongLongToShort
//
// UINT64 -> USHORT conversion
//
# define UInt64ToUShort ULongLongToUShort
//
// UINT64 -> UINT16 conversion
//
# define UInt64ToUInt16 ULongLongToUShort
//
// UINT64 -> WORD conversion
//
# define UInt64ToWord ULongLongToUShort
//
// UINT64 -> INT conversion
//
# define UInt64ToInt ULongLongToInt
//
// UINT64 -> INT32 conversion
//
# define UInt64ToInt32 ULongLongToInt
//
// UINT64 -> INT_PTR conversion
//
# define UInt64ToIntPtr ULongLongToIntPtr
//
// UINT64 -> UINT conversion
//
# define UInt64ToUInt ULongLongToUInt
//
// UINT64 -> UINT32 conversion
//
# define UInt64ToUInt32 ULongLongToUInt
//
// UINT64 -> UINT_PTR conversion
//
# define UInt64ToUIntPtr ULongLongToUIntPtr
//
// UINT64 -> LONG conversion
//
# define UInt64ToLong ULongLongToLong
//
// UINT64 -> LONG_PTR conversion
//
# define UInt64ToLongPtr ULongLongToLongPtr
//
// UINT64 -> ULONG conversion
//
# define UInt64ToULong ULongLongToULong
//
// UINT64 -> ULONG_PTR conversion
//
# define UInt64ToULongPtr ULongLongToULongPtr
//
// UINT64 -> DWORD conversion
//
# define UInt64ToDWord ULongLongToULong
//
// UINT64 -> DWORD_PTR conversion
//
# define UInt64ToDWordPtr ULongLongToULongPtr
//
// UINT64 -> LONGLONG conversion
//
# define UInt64ToLongLong ULongLongToLongLong
//
// UINT64 -> LONG64 conversion
//
# define UInt64ToLong64 ULongLongToLongLong
//
// UINT64 -> INT64 conversion
//
# define UInt64ToInt64 ULongLongToLongLong
//
// UINT64 -> ptrdiff_t conversion
//
# define UInt64ToPtrdiffT ULongLongToIntPtr
//
// UINT64 -> size_t conversion
//
# define UInt64ToSizeT ULongLongToUIntPtr
//
// UINT64 -> SSIZE_T conversion
//
# define UInt64ToSSIZET ULongLongToLongPtr
//
// UINT64 -> SIZE_T conversion
//
# define UInt64ToSIZET ULongLongToULongPtr
//
// ptrdiff_t -> CHAR conversion
//
# define PtrdiffTToChar IntPtrToChar
//
// ptrdiff_t -> INT8 conversion
//
# define PtrdiffTToInt8 IntPtrToInt8
//
// ptrdiff_t -> UCHAR conversion
//
# define PtrdiffTToUChar IntPtrToUChar
//
// ptrdiff_t -> UINT8 conversion
//
# define PtrdiffTToUInt8 IntPtrToUInt8
//
// ptrdiff_t -> BYTE conversion
//
# define PtrdiffTToByte IntPtrToUInt8
//
// ptrdiff_t -> SHORT conversion
//
# define PtrdiffTToShort IntPtrToShort
//
// ptrdiff_t -> INT16 conversion
//
# define PtrdiffTToInt16 IntPtrToShort
//
// ptrdiff_t -> USHORT conversion
//
# define PtrdiffTToUShort IntPtrToUShort
//
// ptrdiff_t -> UINT16 conversion
//
# define PtrdiffTToUInt16 IntPtrToUShort
//
// ptrdiff_t -> WORD conversion
//
# define PtrdiffTToWord IntPtrToUShort
//
// ptrdiff_t -> INT conversion
//
# define PtrdiffTToInt IntPtrToInt
//
// ptrdiff_t -> INT32 conversion
//
# define PtrdiffTToInt32 IntPtrToInt
//
// ptrdiff_t -> UINT conversion
//
# define PtrdiffTToUInt IntPtrToUInt
//
// ptrdiff_t -> UINT32 conversion
//
# define PtrdiffTToUInt32 IntPtrToUInt
//
// ptrdiff_t -> UINT_PTR conversion
//
# define PtrdiffTToUIntPtr IntPtrToUIntPtr
//
// ptrdiff_t -> LONG conversion
//
# define PtrdiffTToLong IntPtrToLong
//
// ptrdiff_t -> LONG_PTR conversion
//
# define PtrdiffTToLongPtr IntPtrToLongPtr
//
// ptrdiff_t -> ULONG conversion
//
# define PtrdiffTToULong IntPtrToULong
//
// ptrdiff_t -> ULONG_PTR conversion
//
# define PtrdiffTToULongPtr IntPtrToULongPtr
//
// ptrdiff_t -> DWORD conversion
//
# define PtrdiffTToDWord IntPtrToULong
//
// ptrdiff_t -> DWORD_PTR conversion
//
# define PtrdiffTToDWordPtr IntPtrToULongPtr
//
// ptrdiff_t -> ULONGLONG conversion
//
# define PtrdiffTToULongLong IntPtrToULongLong
//
// ptrdiff_t -> DWORDLONG conversion
//
# define PtrdiffTToDWordLong IntPtrToULongLong
//
// ptrdiff_t -> ULONG64 conversion
//
# define PtrdiffTToULong64 IntPtrToULongLong
//
// ptrdiff_t -> DWORD64 conversion
//
# define PtrdiffTToDWord64 IntPtrToULongLong
//
// ptrdiff_t -> UINT64 conversion
//
# define PtrdiffTToUInt64 IntPtrToULongLong
//
// ptrdiff_t -> size_t conversion
//
# define PtrdiffTToSizeT IntPtrToUIntPtr
//
// ptrdiff_t -> SIZE_T conversion
//
# define PtrdiffTToSIZET IntPtrToULongPtr
//
// size_t -> INT8 conversion
//
# define SizeTToInt8 UIntPtrToInt8
//
// size_t -> UCHAR conversion
//
# define SizeTToUChar UIntPtrToUChar
//
// size_t -> CHAR conversion
//
# define SizeTToChar UIntPtrToChar
//
// size_t -> UINT8 conversion
//
# define SizeTToUInt8 UIntPtrToUInt8
//
// size_t -> BYTE conversion
//
# define SizeTToByte UIntPtrToUInt8
//
// size_t -> SHORT conversion
//
# define SizeTToShort UIntPtrToShort
//
// size_t -> INT16 conversion
//
# define SizeTToInt16 UIntPtrToShort
//
// size_t -> USHORT conversion
//
# define SizeTToUShort UIntPtrToUShort
//
// size_t -> UINT16 conversion
//
# define SizeTToUInt16 UIntPtrToUShort
//
// size_t -> WORD
//
# define SizeTToWord UIntPtrToUShort
//
// size_t -> INT conversion
//
# define SizeTToInt UIntPtrToInt
//
// size_t -> INT32 conversion
//
# define SizeTToInt32 UIntPtrToInt
//
// size_t -> INT_PTR conversion
//
# define SizeTToIntPtr UIntPtrToIntPtr
//
// size_t -> UINT conversion
//
# define SizeTToUInt UIntPtrToUInt
//
// size_t -> UINT32 conversion
//
# define SizeTToUInt32 UIntPtrToUInt
//
// size_t -> LONG conversion
//
# define SizeTToLong UIntPtrToLong
//
// size_t -> LONG_PTR conversion
//
# define SizeTToLongPtr UIntPtrToLongPtr
//
// size_t -> ULONG conversion
//
# define SizeTToULong UIntPtrToULong
//
// size_t -> DWORD conversion
//
# define SizeTToDWord UIntPtrToULong
//
// size_t -> LONGLONG conversion
//
# define SizeTToLongLong UIntPtrToLongLong
//
// size_t -> LONG64 conversion
//
# define SizeTToLong64 UIntPtrToLongLong
//
// size_t -> INT64
//
# define SizeTToInt64 UIntPtrToLongLong
//
// size_t -> ptrdiff_t conversion
//
# define SizeTToPtrdiffT UIntPtrToIntPtr
//
// size_t -> SSIZE_T conversion
//
# define SizeTToSSIZET UIntPtrToLongPtr
//
// SSIZE_T -> INT8 conversion
//
# define SSIZETToInt8 LongPtrToInt8
//
// SSIZE_T -> UCHAR conversion
//
# define SSIZETToUChar LongPtrToUChar
//
// SSIZE_T -> CHAR conversion
//
# define SSIZETToChar LongPtrToChar
//
// SSIZE_T -> UINT8 conversion
//
# define SSIZETToUInt8 LongPtrToUInt8
//
// SSIZE_T -> BYTE conversion
//
# define SSIZETToByte LongPtrToUInt8
//
// SSIZE_T -> SHORT conversion
//
# define SSIZETToShort LongPtrToShort
//
// SSIZE_T -> INT16 conversion
//
# define SSIZETToInt16 LongPtrToShort
//
// SSIZE_T -> USHORT conversion
//
# define SSIZETToUShort LongPtrToUShort
//
// SSIZE_T -> UINT16 conversion
//
# define SSIZETToUInt16 LongPtrToUShort
//
// SSIZE_T -> WORD conversion
//
# define SSIZETToWord LongPtrToUShort
//
// SSIZE_T -> INT conversion
//
# define SSIZETToInt LongPtrToInt
//
// SSIZE_T -> INT32 conversion
//
# define SSIZETToInt32 LongPtrToInt
//
// SSIZE_T -> INT_PTR conversion
//
# define SSIZETToIntPtr LongPtrToIntPtr
//
// SSIZE_T -> UINT conversion
//
# define SSIZETToUInt LongPtrToUInt
//
// SSIZE_T -> UINT32 conversion
//
# define SSIZETToUInt32 LongPtrToUInt
//
// SSIZE_T -> UINT_PTR conversion
//
# define SSIZETToUIntPtr LongPtrToUIntPtr
//
// SSIZE_T -> LONG conversion
//
# define SSIZETToLong LongPtrToLong
//
// SSIZE_T -> ULONG conversion
//
# define SSIZETToULong LongPtrToULong
//
// SSIZE_T -> ULONG_PTR conversion
//
# define SSIZETToULongPtr LongPtrToULongPtr
//
// SSIZE_T -> DWORD conversion
//
# define SSIZETToDWord LongPtrToULong
//
// SSIZE_T -> DWORD_PTR conversion
//
# define SSIZETToDWordPtr LongPtrToULongPtr
//
// SSIZE_T -> ULONGLONG conversion
//
# define SSIZETToULongLong LongPtrToULongLong
//
// SSIZE_T -> DWORDLONG conversion
//
# define SSIZETToDWordLong LongPtrToULongLong
//
// SSIZE_T -> ULONG64 conversion
//
# define SSIZETToULong64 LongPtrToULongLong
//
// SSIZE_T -> DWORD64 conversion
//
# define SSIZETToDWord64 LongPtrToULongLong
//
// SSIZE_T -> UINT64 conversion
//
# define SSIZETToUInt64 LongPtrToULongLong
//
// SSIZE_T -> size_t conversion
//
# define SSIZETToSizeT LongPtrToUIntPtr
//
// SSIZE_T -> SIZE_T conversion
//
# define SSIZETToSIZET LongPtrToULongPtr
//
// SIZE_T -> INT8 conversion
//
# define SIZETToInt8 ULongPtrToInt8
//
// SIZE_T -> UCHAR conversion
//
# define SIZETToUChar ULongPtrToUChar
//
// SIZE_T -> CHAR conversion
//
# define SIZETToChar ULongPtrToChar
//
// SIZE_T -> UINT8 conversion
//
# define SIZETToUInt8 ULongPtrToUInt8
//
// SIZE_T -> BYTE conversion
//
# define SIZETToByte ULongPtrToUInt8
//
// SIZE_T -> SHORT conversion
//
# define SIZETToShort ULongPtrToShort
//
// SIZE_T -> INT16 conversion
//
# define SIZETToInt16 ULongPtrToShort
//
// SIZE_T -> USHORT conversion
//
# define SIZETToUShort ULongPtrToUShort
//
// SIZE_T -> UINT16 conversion
//
# define SIZETToUInt16 ULongPtrToUShort
//
// SIZE_T -> WORD
//
# define SIZETToWord ULongPtrToUShort
//
// SIZE_T -> INT conversion
//
# define SIZETToInt ULongPtrToInt
//
// SIZE_T -> INT32 conversion
//
# define SIZETToInt32 ULongPtrToInt
//
// SIZE_T -> INT_PTR conversion
//
# define SIZETToIntPtr ULongPtrToIntPtr
//
// SIZE_T -> UINT conversion
//
# define SIZETToUInt ULongPtrToUInt
//
// SIZE_T -> UINT32 conversion
//
# define SIZETToUInt32 ULongPtrToUInt
//
// SIZE_T -> UINT_PTR conversion
//
# define SIZETToUIntPtr ULongPtrToUIntPtr
//
// SIZE_T -> LONG conversion
//
# define SIZETToLong ULongPtrToLong
//
// SIZE_T -> LONG_PTR conversion
//
# define SIZETToLongPtr ULongPtrToLongPtr
//
// SIZE_T -> ULONG conversion
//
# define SIZETToULong ULongPtrToULong
//
// SIZE_T -> DWORD conversion
//
# define SIZETToDWord ULongPtrToULong
//
// SIZE_T -> LONGLONG conversion
//
# define SIZETToLongLong ULongPtrToLongLong
//
// SIZE_T -> LONG64 conversion
//
# define SIZETToLong64 ULongPtrToLongLong
//
// SIZE_T -> INT64
//
# define SIZETToInt64 ULongPtrToLongLong
//
// SIZE_T -> ptrdiff_t conversion
//
# define SIZETToPtrdiffT ULongPtrToIntPtr
//
// SIZE_T -> SSIZE_T conversion
//
# define SIZETToSSIZET ULongPtrToLongPtr
//=============================================================================
// Addition functions
//=============================================================================
//
// UINT8 addition
//
__inline
HRESULT
UInt8Add (
__inn UINT8 u8Augend ,
__inn UINT8 u8Addend ,
__outt __deref_out_range ( = = , u8Augend + u8Addend ) UINT8 * pu8Result )
{
HRESULT hr ;
if ( ( ( UINT8 ) ( u8Augend + u8Addend ) ) > = u8Augend )
{
* pu8Result = ( UINT8 ) ( u8Augend + u8Addend ) ;
hr = S_OK ;
}
else
{
* pu8Result = UINT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// USHORT addition
//
__inline
HRESULT
UShortAdd (
__inn USHORT usAugend ,
__inn USHORT usAddend ,
__outt __deref_out_range ( = = , usAugend + usAddend ) USHORT * pusResult )
{
HRESULT hr ;
if ( ( ( USHORT ) ( usAugend + usAddend ) ) > = usAugend )
{
* pusResult = ( USHORT ) ( usAugend + usAddend ) ;
hr = S_OK ;
}
else
{
* pusResult = USHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT16 addition
//
# define UInt16Add UShortAdd
//
// WORD addtition
//
# define WordAdd UShortAdd
//
// UINT addition
//
__inline
HRESULT
UIntAdd (
__inn UINT uAugend ,
__inn UINT uAddend ,
__outt __deref_out_range ( = = , uAugend + uAddend ) UINT * puResult )
{
HRESULT hr ;
if ( ( uAugend + uAddend ) > = uAugend )
{
* puResult = ( uAugend + uAddend ) ;
hr = S_OK ;
}
else
{
* puResult = UINT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT32 addition
//
# define UInt32Add UIntAdd
//
// UINT_PTR addition
//
# ifdef _WIN64
# define UIntPtrAdd ULongLongAdd
# else
__inline
HRESULT
UIntPtrAdd (
__inn UINT_PTR uAugend ,
__inn UINT_PTR uAddend ,
__outt __deref_out_range ( = = , uAugend + uAddend ) UINT_PTR * puResult )
{
HRESULT hr ;
if ( ( uAugend + uAddend ) > = uAugend )
{
* puResult = ( uAugend + uAddend ) ;
hr = S_OK ;
}
else
{
* puResult = UINT_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
# endif // _WIN64
//
// ULONG addition
//
__inline
HRESULT
ULongAdd (
__inn ULONG ulAugend ,
__inn ULONG ulAddend ,
__outt __deref_out_range ( = = , ulAugend + ulAddend ) ULONG * pulResult )
{
HRESULT hr ;
if ( ( ulAugend + ulAddend ) > = ulAugend )
{
* pulResult = ( ulAugend + ulAddend ) ;
hr = S_OK ;
}
else
{
* pulResult = ULONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONG_PTR addition
//
# ifdef _WIN64
# define ULongPtrAdd ULongLongAdd
# else
__inline
HRESULT
ULongPtrAdd (
__inn ULONG_PTR ulAugend ,
__inn ULONG_PTR ulAddend ,
__outt __deref_out_range ( = = , ulAugend + ulAddend ) ULONG_PTR * pulResult )
{
HRESULT hr ;
if ( ( ulAugend + ulAddend ) > = ulAugend )
{
* pulResult = ( ulAugend + ulAddend ) ;
hr = S_OK ;
}
else
{
* pulResult = ULONG_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
# endif // _WIN64
//
// DWORD addition
//
# define DWordAdd ULongAdd
//
// DWORD_PTR addition
//
# ifdef _WIN64
# define DWordPtrAdd ULongLongAdd
# else
__inline
HRESULT
DWordPtrAdd (
__inn DWORD_PTR dwAugend ,
__inn DWORD_PTR dwAddend ,
__outt __deref_out_range ( = = , dwAugend + dwAddend ) DWORD_PTR * pdwResult )
{
HRESULT hr ;
if ( ( dwAugend + dwAddend ) > = dwAugend )
{
* pdwResult = ( dwAugend + dwAddend ) ;
hr = S_OK ;
}
else
{
* pdwResult = DWORD_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
# endif // _WIN64
//
// size_t addition
//
__inline
HRESULT
SizeTAdd (
__inn size_t Augend ,
__inn size_t Addend ,
__outt __deref_out_range ( = = , Augend + Addend ) size_t * pResult )
{
HRESULT hr ;
if ( ( Augend + Addend ) > = Augend )
{
* pResult = ( Augend + Addend ) ;
hr = S_OK ;
}
else
{
* pResult = SIZE_T_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// SIZE_T addition
//
# ifdef _WIN64
# define SIZETAdd ULongLongAdd
# else
__inline
HRESULT
SIZETAdd (
__inn SIZE_T Augend ,
__inn SIZE_T Addend ,
__outt __deref_out_range ( = = , Augend + Addend ) SIZE_T * pResult )
{
HRESULT hr ;
if ( ( Augend + Addend ) > = Augend )
{
* pResult = ( Augend + Addend ) ;
hr = S_OK ;
}
else
{
* pResult = _SIZE_T_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
# endif // _WIN64
//
// ULONGLONG addition
//
__inline
HRESULT
ULongLongAdd (
__inn ULONGLONG ullAugend ,
__inn ULONGLONG ullAddend ,
__outt __deref_out_range ( = = , ullAugend + ullAddend ) ULONGLONG * pullResult )
{
HRESULT hr ;
if ( ( ullAugend + ullAddend ) > = ullAugend )
{
* pullResult = ( ullAugend + ullAddend ) ;
hr = S_OK ;
}
else
{
* pullResult = ULONGLONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// DWORDLONG addition
//
# define DWordLongAdd ULongLongAdd
//
// ULONG64 addition
//
# define ULong64Add ULongLongAdd
//
// DWORD64 addition
//
# define DWord64Add ULongLongAdd
//
// UINT64 addition
//
# define UInt64Add ULongLongAdd
//=============================================================================
// Subtraction functions
//=============================================================================
//
// UINT8 subtraction
//
__inline
HRESULT
UInt8Sub (
__inn UINT8 u8Minuend ,
__inn UINT8 u8Subtrahend ,
__outt __deref_out_range ( = = , u8Minuend - u8Subtrahend ) UINT8 * pu8Result )
{
HRESULT hr ;
if ( u8Minuend > = u8Subtrahend )
{
* pu8Result = ( UINT8 ) ( u8Minuend - u8Subtrahend ) ;
hr = S_OK ;
}
else
{
* pu8Result = UINT8_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// USHORT subtraction
//
__inline
HRESULT
UShortSub (
__inn USHORT usMinuend ,
__inn USHORT usSubtrahend ,
__outt __deref_out_range ( = = , usMinuend - usSubtrahend ) USHORT * pusResult )
{
HRESULT hr ;
if ( usMinuend > = usSubtrahend )
{
* pusResult = ( USHORT ) ( usMinuend - usSubtrahend ) ;
hr = S_OK ;
}
else
{
* pusResult = USHORT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT16 subtraction
//
# define UInt16Sub UShortSub
//
// WORD subtraction
//
# define WordSub UShortSub
//
// UINT subtraction
//
__inline
HRESULT
UIntSub (
__inn UINT uMinuend ,
__inn UINT uSubtrahend ,
__outt __deref_out_range ( = = , uMinuend - uSubtrahend ) UINT * puResult )
{
HRESULT hr ;
if ( uMinuend > = uSubtrahend )
{
* puResult = ( uMinuend - uSubtrahend ) ;
hr = S_OK ;
}
else
{
* puResult = UINT_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// UINT32 subtraction
//
# define UInt32Sub UIntSub
//
// UINT_PTR subtraction
//
# ifdef _WIN64
# define UIntPtrSub ULongLongSub
# else
__inline
HRESULT
UIntPtrSub (
__inn UINT_PTR uMinuend ,
__inn UINT_PTR uSubtrahend ,
__outt __deref_out_range ( = = , uMinuend - uSubtrahend ) UINT_PTR * puResult )
{
HRESULT hr ;
if ( uMinuend > = uSubtrahend )
{
* puResult = ( uMinuend - uSubtrahend ) ;
hr = S_OK ;
}
else
{
* puResult = UINT_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
# endif // _WIN64
//
// ULONG subtraction
//
__inline
HRESULT
ULongSub (
__inn ULONG ulMinuend ,
__inn ULONG ulSubtrahend ,
__outt __deref_out_range ( = = , ulMinuend - ulSubtrahend ) ULONG * pulResult )
{
HRESULT hr ;
if ( ulMinuend > = ulSubtrahend )
{
* pulResult = ( ulMinuend - ulSubtrahend ) ;
hr = S_OK ;
}
else
{
* pulResult = ULONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// ULONG_PTR subtraction
//
# ifdef _WIN64
# define ULongPtrSub ULongLongSub
# else
__inline
HRESULT
ULongPtrSub (
__inn ULONG_PTR ulMinuend ,
__inn ULONG_PTR ulSubtrahend ,
__outt __deref_out_range ( = = , ulMinuend - ulSubtrahend ) ULONG_PTR * pulResult )
{
HRESULT hr ;
if ( ulMinuend > = ulSubtrahend )
{
* pulResult = ( ulMinuend - ulSubtrahend ) ;
hr = S_OK ;
}
else
{
* pulResult = ULONG_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
# endif // _WIN64
//
// DWORD subtraction
//
# define DWordSub ULongSub
//
// DWORD_PTR subtraction
//
# ifdef _WIN64
# define DWordPtrSub ULongLongSub
# else
__inline
HRESULT
DWordPtrSub (
__inn DWORD_PTR dwMinuend ,
__inn DWORD_PTR dwSubtrahend ,
__outt __deref_out_range ( = = , dwMinuend - dwSubtrahend ) DWORD_PTR * pdwResult )
{
HRESULT hr ;
if ( dwMinuend > = dwSubtrahend )
{
* pdwResult = ( dwMinuend - dwSubtrahend ) ;
hr = S_OK ;
}
else
{
* pdwResult = DWORD_PTR_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
# endif // _WIN64
//
// size_t subtraction
//
__inline
HRESULT
SizeTSub (
__inn size_t Minuend ,
__inn size_t Subtrahend ,
__outt __deref_out_range ( = = , Minuend - Subtrahend ) size_t * pResult )
{
HRESULT hr ;
if ( Minuend > = Subtrahend )
{
* pResult = ( Minuend - Subtrahend ) ;
hr = S_OK ;
}
else
{
* pResult = SIZE_T_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// SIZE_T subtraction
//
# ifdef _WIN64
# define SIZETSub ULongLongSub
# else
__inline
HRESULT
SIZETSub (
__inn SIZE_T Minuend ,
__inn SIZE_T Subtrahend ,
__outt __deref_out_range ( = = , Minuend - Subtrahend ) SIZE_T * pResult )
{
HRESULT hr ;
if ( Minuend > = Subtrahend )
{
* pResult = ( Minuend - Subtrahend ) ;
hr = S_OK ;
}
else
{
* pResult = _SIZE_T_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
# endif // _WIN64
//
// ULONGLONG subtraction
//
__inline
HRESULT
ULongLongSub (
__inn ULONGLONG ullMinuend ,
__inn ULONGLONG ullSubtrahend ,
__outt __deref_out_range ( = = , ullMinuend - ullSubtrahend ) ULONGLONG * pullResult )
{
HRESULT hr ;
if ( ullMinuend > = ullSubtrahend )
{
* pullResult = ( ullMinuend - ullSubtrahend ) ;
hr = S_OK ;
}
else
{
* pullResult = ULONGLONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
return hr ;
}
//
// DWORDLONG subtraction
//
# define DWordLongSub ULongLongSub
//
// ULONG64 subtraction
//
# define ULong64Sub ULongLongSub
//
// DWORD64 subtraction
//
# define DWord64Sub ULongLongSub
//
// UINT64 subtraction
//
# define UInt64Sub ULongLongSub
//=============================================================================
// Multiplication functions
//=============================================================================
//
// UINT8 multiplication
//
__inline
HRESULT
UInt8Mult (
__inn UINT8 u8Multiplicand ,
__inn UINT8 u8Multiplier ,
__outt __deref_out_range ( = = , u8Multiplier * u8Multiplicand ) UINT8 * pu8Result )
{
UINT uResult = ( ( UINT ) u8Multiplicand ) * ( ( UINT ) u8Multiplier ) ;
return UIntToUInt8 ( uResult , pu8Result ) ;
}
//
// USHORT multiplication
//
__inline
HRESULT
UShortMult (
__inn USHORT usMultiplicand ,
__inn USHORT usMultiplier ,
__outt __deref_out_range ( = = , usMultiplier * usMultiplicand ) USHORT * pusResult )
{
ULONG ulResult = ( ( ULONG ) usMultiplicand ) * ( ( ULONG ) usMultiplier ) ;
return ULongToUShort ( ulResult , pusResult ) ;
}
//
// UINT16 multiplication
//
# define UInt16Mult UShortMult
//
// WORD multiplication
//
# define WordMult UShortMult
//
// UINT multiplication
//
__inline
HRESULT
UIntMult (
__inn UINT uMultiplicand ,
__inn UINT uMultiplier ,
__outt __deref_out_range ( = = , uMultiplier * uMultiplicand ) UINT * puResult )
{
ULONGLONG ull64Result = UInt32x32To64 ( uMultiplicand , uMultiplier ) ;
return ULongLongToUInt ( ull64Result , puResult ) ;
}
//
// UINT32 multiplication
//
# define UInt32Mult UIntMult
//
// UINT_PTR multiplication
//
# ifdef _WIN64
# define UIntPtrMult ULongLongMult
# else
__inline
HRESULT
UIntPtrMult (
__inn UINT_PTR uMultiplicand ,
__inn UINT_PTR uMultiplier ,
__outt __deref_out_range ( = = , uMultiplier * uMultiplicand ) UINT_PTR * puResult )
{
ULONGLONG ull64Result = UInt32x32To64 ( uMultiplicand , uMultiplier ) ;
return ULongLongToUIntPtr ( ull64Result , puResult ) ;
}
# endif // _WIN64
//
// ULONG multiplication
//
__inline
HRESULT
ULongMult (
__inn ULONG ulMultiplicand ,
__inn ULONG ulMultiplier ,
__outt __deref_out_range ( = = , ulMultiplier * ulMultiplicand ) ULONG * pulResult )
{
ULONGLONG ull64Result = UInt32x32To64 ( ulMultiplicand , ulMultiplier ) ;
return ULongLongToULong ( ull64Result , pulResult ) ;
}
//
// ULONG_PTR multiplication
//
# ifdef _WIN64
# define ULongPtrMult ULongLongMult
# else
__inline
HRESULT
ULongPtrMult (
__inn ULONG_PTR ulMultiplicand ,
__inn ULONG_PTR ulMultiplier ,
__outt __deref_out_range ( = = , ulMultiplier * ulMultiplicand ) ULONG_PTR * pulResult )
{
ULONGLONG ull64Result = UInt32x32To64 ( ulMultiplicand , ulMultiplier ) ;
return ULongLongToULongPtr ( ull64Result , ( unsigned long * ) pulResult ) ;
}
# endif // _WIN64
//
// DWORD multiplication
//
# define DWordMult ULongMult
//
// DWORD_PTR multiplication
//
# ifdef _WIN64
# define DWordPtrMult ULongLongMult
# else
__inline
HRESULT
DWordPtrMult (
__inn DWORD_PTR dwMultiplicand ,
__inn DWORD_PTR dwMultiplier ,
__outt __deref_out_range ( = = , dwMultiplier * dwMultiplicand ) DWORD_PTR * pdwResult )
{
ULONGLONG ull64Result = UInt32x32To64 ( dwMultiplicand , dwMultiplier ) ;
return ULongLongToDWordPtr ( ull64Result , ( unsigned long * ) pdwResult ) ;
}
# endif // _WIN64
//
// size_t multiplication
//
# ifdef _WIN64
# define SizeTMult ULongLongMult
# else
__inline
HRESULT
SizeTMult (
__inn size_t Multiplicand ,
__inn size_t Multiplier ,
__outt __deref_out_range ( = = , Multiplier * Multiplicand ) UINT * pResult )
{
ULONGLONG ull64Result = UInt32x32To64 ( Multiplicand , Multiplier ) ;
return ULongLongToSizeT ( ull64Result , pResult ) ;
}
# endif // _WIN64
//
// SIZE_T multiplication
//
# ifdef _WIN64
# define SIZETMult ULongLongMult
# else
__inline
HRESULT
SIZETMult (
__inn SIZE_T Multiplicand ,
__inn SIZE_T Multiplier ,
__outt __deref_out_range ( = = , Multiplier * Multiplicand ) SIZE_T * pResult )
{
ULONGLONG ull64Result = UInt32x32To64 ( Multiplicand , Multiplier ) ;
return ULongLongToSIZET ( ull64Result , ( unsigned long * ) pResult ) ;
}
# endif // _WIN64
//
// ULONGLONG multiplication
//
__inline
HRESULT
ULongLongMult (
__inn ULONGLONG ullMultiplicand ,
__inn ULONGLONG ullMultiplier ,
__outt __deref_out_range ( = = , ullMultiplier * ullMultiplicand ) ULONGLONG * pullResult )
{
HRESULT hr ;
# ifdef _AMD64_
ULONGLONG u64ResultHigh ;
ULONGLONG u64ResultLow ;
u64ResultLow = UnsignedMultiply128 ( ullMultiplicand , ullMultiplier , & u64ResultHigh ) ;
if ( u64ResultHigh = = 0 )
{
* pullResult = u64ResultLow ;
hr = S_OK ;
}
else
{
* pullResult = ULONGLONG_ERROR ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
}
# else
// 64x64 into 128 is like 32.32 x 32.32.
//
// a.b * c.d = a*(c.d) + .b*(c.d) = a*c + a*.d + .b*c + .b*.d
// back in non-decimal notation where A=a*2^32 and C=c*2^32:
// A*C + A*d + b*C + b*d
// So there are four components to add together.
// result = (a*c*2^64) + (a*d*2^32) + (b*c*2^32) + (b*d)
//
// a * c must be 0 or there would be bits in the high 64-bits
// a * d must be less than 2^32 or there would be bits in the high 64-bits
// b * c must be less than 2^32 or there would be bits in the high 64-bits
// then there must be no overflow of the resulting values summed up.
ULONG dw_a ;
ULONG dw_b ;
ULONG dw_c ;
ULONG dw_d ;
ULONGLONG ad = 0 ;
ULONGLONG bc = 0 ;
ULONGLONG bd = 0 ;
ULONGLONG ullResult = 0 ;
hr = INTSAFE_E_ARITHMETIC_OVERFLOW ;
dw_a = ( ULONG ) ( ullMultiplicand > > 32 ) ;
dw_c = ( ULONG ) ( ullMultiplier > > 32 ) ;
// common case -- if high dwords are both zero, no chance for overflow
if ( ( dw_a = = 0 ) & & ( dw_c = = 0 ) )
{
dw_b = ( DWORD ) ullMultiplicand ;
dw_d = ( DWORD ) ullMultiplier ;
* pullResult = ( ( ( ULONGLONG ) dw_b ) * ( ULONGLONG ) dw_d ) ;
hr = S_OK ;
}
else
{
// a * c must be 0 or there would be bits set in the high 64-bits
if ( ( dw_a = = 0 ) | |
( dw_c = = 0 ) )
{
dw_d = ( DWORD ) ullMultiplier ;
// a * d must be less than 2^32 or there would be bits set in the high 64-bits
ad = ( ( ( ULONGLONG ) dw_a ) * ( ULONGLONG ) dw_d ) ;
if ( ( ad & 0xffffffff00000000LL ) = = 0 )
{
dw_b = ( DWORD ) ullMultiplicand ;
// b * c must be less than 2^32 or there would be bits set in the high 64-bits
bc = ( ( ( ULONGLONG ) dw_b ) * ( ULONGLONG ) dw_c ) ;
if ( ( bc & 0xffffffff00000000LL ) = = 0 )
{
// now sum them all up checking for overflow.
// shifting is safe because we already checked for overflow above
if ( SUCCEEDED ( ULongLongAdd ( bc < < 32 , ad < < 32 , & ullResult ) ) )
{
// b * d
bd = ( ( ( ULONGLONG ) dw_b ) * ( ULONGLONG ) dw_d ) ;
if ( SUCCEEDED ( ULongLongAdd ( ullResult , bd , & ullResult ) ) )
{
* pullResult = ullResult ;
hr = S_OK ;
}
}
}
}
}
}
if ( FAILED ( hr ) )
{
* pullResult = ULONGLONG_ERROR ;
}
# endif // _AMD64_
return hr ;
}
//
// DWORDLONG multiplication
//
# define DWordLongMult ULongLongMult
//
// ULONG64 multiplication
//
# define ULong64Mult ULongLongMult
//
// DWORD64 multiplication
//
# define DWord64Mult ULongLongMult
//
// UINT64 multiplication
//
# define UInt64Mult ULongLongMult
//
// Macros that are no longer used in this header but which clients may
// depend on being defined here.
//
# define LOWORD(_dw) ((WORD)(((DWORD_PTR)(_dw)) & 0xffff))
# define HIWORD(_dw) ((WORD)((((DWORD_PTR)(_dw)) >> 16) & 0xffff))
# define LODWORD(_qw) ((DWORD)(_qw))
# define HIDWORD(_qw) ((DWORD)(((_qw) >> 32) & 0xffffffff))
# endif // XPLAT_INTSAFE_H