dprevot/php-sqlsrv
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Removed unused xplat functions

Browse source
This commit is contained in:
David Puglielli 2017-05-15 16:22:58 -07:00
parent 4537021d1b
commit a297fe0c54
10 changed files with 9 additions and 9529 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1191
source/shared/FormattedPrint.cpp
View file

@ -233,10 +233,6 @@ static const unsigned char __lookuptable_s[] = {
/* 'x' */ 0x08
};
static inline CHARTYPE GetCharType( WCHAR wch )
{
return ((wch < (L' ') || wch > (L'x')) ? CH_OTHER : (enum CHARTYPE)(__lookuptable_s[wch - (L' ')] & 0xF));
}
static inline CHARTYPE GetCharType( char ch )
{
return ((ch < (' ') || ch > ('x')) ? CH_OTHER : (enum CHARTYPE)(__lookuptable_s[ch - (' ')] & 0xF));
@ -251,10 +247,6 @@ static bool isleadbyte(unsigned char ch)
{
return (FALSE != IsDBCSLeadByte(ch) );
}
static bool isleadwchar(WCHAR ch)
{
return ((ch & 0xFC00) == 0xD800);
}
static bool _isleadbyte_l(unsigned char ch, _locale_t loc)
{
// XPLAT_ODBC_TODO VSTS 718708 Localization
@ -277,22 +269,6 @@ errno_t mplat_wctomb_s(
return (ERROR_SUCCESS == rc ? 0 : -1);
}
#define _MBTOWC mplat_mbtowc
int mplat_mbtowc(
WCHAR * pwchar,
const char * pmb,
size_t n
)
{
size_t cch = SystemLocale::NextChar( CP_ACP, pmb ) - pmb;
if ( 0 < cch )
{
size_t cchActual = SystemLocale::ToUtf16( CP_ACP, pmb, cch, pwchar, 1, NULL );
assert( cch == cchActual );
}
return (int)cch;
}
// Floating point print routines
void _CFLTCVT( double * dbl, char * buf, int bufSize, char fmt, int precision, int caps, _locale_t loc = NULL )
{
@ -406,85 +382,6 @@ static enum STATE ProcessSizeA( char sizeCh, char fmt_ch, char next_fmt_ch, int
return ST_SIZE;
}
static enum STATE ProcessSizeW( WCHAR sizeCh, WCHAR fmt_ch, WCHAR next_fmt_ch, int * advance, int * flags )
{
*advance = 0;
switch (sizeCh)
{
case L'l':
/*
* In order to handle the ll case, we depart from the
* simple deterministic state machine.
*/
if ( L'l' == fmt_ch )
{
*advance = 1;
*flags |= FL_LONGLONG;
}
else
{
*flags |= FL_LONG;
}
break;
case L'I':
/*
* In order to handle the I, I32, and I64 size modifiers, we
* depart from the simple deterministic state machine. The
* code below scans for characters following the 'I',
* and defaults to 64 bit on WIN64 and 32 bit on WIN32
*/
#if PTR_IS_INT64
*flags |= FL_I64; /* 'I' => __int64 on WIN64 systems */
#endif /* PTR_IS_INT64 */
if ( L'6' == fmt_ch && L'4' == next_fmt_ch )
{
*advance = 2;
*flags |= FL_I64; /* I64 => __int64 */
}
else if ( L'3' == fmt_ch && L'2' == next_fmt_ch )
{
*advance = 2;
*flags &= ~FL_I64; /* I32 => __int32 */
}
else if (
(fmt_ch == L'd') ||
(fmt_ch == L'i') ||
(fmt_ch == L'o') ||
(fmt_ch == L'u') ||
(fmt_ch == L'x') ||
(fmt_ch == L'X') )
{
/*
* Nothing further needed. %Id (et al) is
* handled just like %d, except that it defaults to 64 bits
* on WIN64. Fall through to the next iteration.
*/
}
else
{
return ST_NORMAL;
}
break;
case L'h':
*flags |= FL_SHORT;
break;
case L'w':
*flags |= FL_WIDECHAR;
}
return ST_SIZE;
}
STATE ProcessSize( WCHAR sizeCh, const WCHAR * format, int * advance, int * flags )
{
WCHAR formatCh = *format;
WCHAR next_formatCh = (L'\0' == formatCh ? L'\0' : *(format+1));
return ProcessSizeW( sizeCh, formatCh, next_formatCh, advance, flags );
}
STATE ProcessSize( char sizeCh, const char * format, int * advance, int * flags )
{
char formatCh = *format;
@ -1075,607 +972,6 @@ int FormattedPrintA( IFormattedPrintOutput<char> * output, const char *format, v
return charsout; /* return value = number of characters written */
}
// Tools\vc\src\crt\amd64\output.c
int FormattedPrintW( IFormattedPrintOutput<WCHAR> * output, const WCHAR *format, va_list argptr )
{
int hexadd=0; /* offset to add to number to get 'a'..'f' */
WCHAR ch; /* character just read */
int flags=0; /* flag word -- see #defines above for flag values */
enum STATE state; /* current state */
enum CHARTYPE chclass; /* class of current character */
int radix; /* current conversion radix */
int charsout; /* characters currently written so far, -1 = IO error */
int fldwidth = 0; /* selected field width -- 0 means default */
int precision = 0; /* selected precision -- -1 means default */
WCHAR prefix[2]; /* numeric prefix -- up to two characters */
int prefixlen=0; /* length of prefix -- 0 means no prefix */
int capexp=0; /* non-zero = 'E' exponent signifient, zero = 'e' or unused */
int no_output=0; /* non-zero = prodcue no output for this specifier */
union {
char *sz; /* pointer text to be printed, not zero terminated */
WCHAR *wz;
} text;
int textlen; /* length of the text in bytes/wchars to be printed.
textlen is in multibyte or wide chars if _UNICODE */
union {
char sz[BUFFERSIZE];
WCHAR wz[BUFFERSIZE];
} buffer;
WCHAR wchar; /* temp wchar_t */
int buffersize; /* size of text.sz (used only for the call to _cfltcvt) */
int bufferiswide=0; /* non-zero = buffer contains wide chars already */
#ifndef _SAFECRT_IMPL
_LocaleUpdate _loc_update(plocinfo);
#endif /* _SAFECRT_IMPL */
char *heapbuf = NULL; /* non-zero = test.sz using heap buffer to be freed */
int advance; /* count of how much helper fxns need format ptr incremented */
_VALIDATE_RETURN( ((output != NULL) && (format != NULL)), EINVAL, -1);
charsout = 0; /* no characters written yet */
textlen = 0; /* no text yet */
state = ST_NORMAL; /* starting state */
heapbuf = NULL; /* not using heap-allocated buffer */
buffersize = 0;
/* main loop -- loop while format character exist and no I/O errors */
while ((ch = *format++) != L'\0' && charsout >= 0) {
// Find char class and next state
chclass = GetCharType( ch );
state = GetState( chclass, state );
/* execute code for each state */
switch (state) {
case ST_INVALID:
// "Incorrect format specifier"
assert( false );
errno = EINVAL;
return -1;
case ST_NORMAL:
NORMAL_STATE:
/* normal state -- just write character */
bufferiswide = 1;
if (isleadwchar(ch)) {
// Deal with more than 2 storage units per character
output->WRITE_CHAR(ch, &charsout);
ch = *format++;
/* don't fall off format string */
_VALIDATE_RETURN( (ch != L'\0'), EINVAL, -1);
}
output->WRITE_CHAR(ch, &charsout);
break;
case ST_PERCENT:
/* set default value of conversion parameters */
prefixlen = fldwidth = no_output = capexp = 0;
flags = 0;
precision = -1;
bufferiswide = 0; /* default */
break;
case ST_FLAG:
/* set flag based on which flag character */
switch (ch) {
case L'-':
flags |= FL_LEFT; /* '-' => left justify */
break;
case L'+':
flags |= FL_SIGN; /* '+' => force sign indicator */
break;
case L' ':
flags |= FL_SIGNSP; /* ' ' => force sign or space */
break;
case L'#':
flags |= FL_ALTERNATE; /* '#' => alternate form */
break;
case L'0':
flags |= FL_LEADZERO; /* '0' => pad with leading zeros */
break;
}
break;
case ST_WIDTH:
/* update width value */
if (ch == L'*') {
/* get width from arg list */
fldwidth = va_arg(argptr, int);
if (fldwidth < 0) {
/* ANSI says neg fld width means '-' flag and pos width */
flags |= FL_LEFT;
fldwidth = -fldwidth;
}
}
else {
/* add digit to current field width */
fldwidth = fldwidth * 10 + (ch - L'0');
}
break;
case ST_DOT:
/* zero the precision, since dot with no number means 0
not default, according to ANSI */
precision = 0;
break;
case ST_PRECIS:
/* update precison value */
if (ch == L'*') {
/* get precision from arg list */
precision = va_arg(argptr, int);
if (precision < 0)
precision = -1; /* neg precision means default */
}
else {
/* add digit to current precision */
precision = precision * 10 + (ch - L'0');
}
break;
case ST_SIZE:
/* just read a size specifier, set the flags based on it */
state = ProcessSize( ch, format, &advance, &flags );
format += advance;
if ( ST_NORMAL == state )
{
goto NORMAL_STATE;
}
break;
case ST_TYPE:
/* we have finally read the actual type character, so we */
/* now format and "print" the output. We use a big switch */
/* statement that sets 'text' to point to the text that should */
/* be printed, and 'textlen' to the length of this text. */
/* Common code later on takes care of justifying it and */
/* other miscellaneous chores. Note that cases share code, */
/* in particular, all integer formatting is done in one place. */
/* Look at those funky goto statements! */
switch (ch) {
case L'C': /* ISO wide character */
if (!(flags & (FL_SHORT|FL_LONG|FL_WIDECHAR)))
flags |= FL_SHORT;
/* fall into 'c' case */
case L'c': {
/* print a single character specified by int argument */
bufferiswide = 1;
wchar = (WCHAR) va_arg(argptr, int);
if (flags & FL_SHORT) {
/* format multibyte character */
/* this is an extension of ANSI */
char tempchar[2];
{
tempchar[0] = (char)(wchar & 0x00ff);
tempchar[1] = '\0';
}
#ifdef _SAFECRT_IMPL
if (_MBTOWC(buffer.wz,tempchar, MB_CUR_MAX) < 0)
#else /* _SAFECRT_IMPL */
if (_mbtowc_l(buffer.wz,
tempchar,
_loc_update.GetLocaleT()->locinfo->mb_cur_max,
_loc_update.GetLocaleT()) < 0)
#endif /* _SAFECRT_IMPL */
{
/* ignore if conversion was unsuccessful */
no_output = 1;
}
} else {
buffer.wz[0] = wchar;
}
text.wz = buffer.wz;
textlen = 1; /* print just a single character */
}
break;
case L'Z': {
// 'Z' format specifier disabled
_VALIDATE_RETURN(0, EINVAL, -1);
}
break;
case L'S': /* ISO wide character string */
if (!(flags & (FL_SHORT|FL_LONG|FL_WIDECHAR)))
flags |= FL_SHORT;
case L's': {
/* print a string -- */
/* ANSI rules on how much of string to print: */
/* all if precision is default, */
/* min(precision, length) if precision given. */
/* prints '(null)' if a null string is passed */
int i;
char *p; /* temps */
WCHAR *pwch;
/* At this point it is tempting to use strlen(), but */
/* if a precision is specified, we're not allowed to */
/* scan past there, because there might be no null */
/* at all. Thus, we must do our own scan. */
i = (precision == -1) ? INT_MAX : precision;
text.sz = (char *)va_arg(argptr, void *);
/* scan for null upto i characters */
if (flags & FL_SHORT) {
if (text.sz == NULL) /* NULL passed, use special string */
text.sz = (char*) __nullstring;
p = text.sz;
for (textlen=0; textlen<i && *p; textlen++) {
#ifdef _SAFECRT_IMPL
if (isleadbyte((unsigned char)(*p)))
#else /* _SAFECRT_IMPL */
if (_isleadbyte_l((unsigned char)(*p), _loc_update.GetLocaleT()))
#endif /* _SAFECRT_IMPL */
++p;
++p;
}
/* textlen now contains length in multibyte chars */
} else {
if (text.wz == NULL) /* NULL passed, use special string */
text.wz = (WCHAR *)__wnullstring;
bufferiswide = 1;
pwch = text.wz;
while (i-- && *pwch)
++pwch;
textlen = (int)(pwch - text.wz); /* in wchar_ts */
/* textlen now contains length in wide chars */
}
}
break;
case L'n': {
// 'n' format specifier disabled
_VALIDATE_RETURN(0, EINVAL, -1);
}
break;
case L'E':
case L'G':
case L'A':
capexp = 1; /* capitalize exponent */
ch += L'a' - L'A'; /* convert format char to lower */
/* DROP THROUGH */
case L'e':
case L'f':
case L'g':
case L'a': {
/* floating point conversion -- we call cfltcvt routines */
/* to do the work for us. */
flags |= FL_SIGNED; /* floating point is signed conversion */
text.sz = buffer.sz; /* put result in buffer */
buffersize = BUFFERSIZE;
/* compute the precision value */
if (precision < 0)
precision = 6; /* default precision: 6 */
else if (precision == 0 && ch == L'g')
precision = 1; /* ANSI specified */
else if (precision > MAXPRECISION)
precision = MAXPRECISION;
if (precision > BUFFERSIZE - _CVTBUFSIZE) {
/* conversion will potentially overflow local buffer */
/* so we need to use a heap-allocated buffer. */
heapbuf = (char *)malloc(_CVTBUFSIZE + precision);
if (heapbuf != NULL)
{
text.sz = heapbuf;
buffersize = _CVTBUFSIZE + precision;
}
else
/* malloc failed, cap precision further */
precision = BUFFERSIZE - _CVTBUFSIZE;
}
#ifdef _SAFECRT_IMPL
/* for safecrt, we pass along the FL_ALTERNATE flag to _safecrt_cfltcvt */
if (flags & FL_ALTERNATE)
{
capexp |= FL_ALTERNATE;
}
#endif /* _SAFECRT_IMPL */
#if !LONGDOUBLE_IS_DOUBLE
/* do the conversion */
if (flags & FL_LONGDOUBLE) {
_LONGDOUBLE tmp;
tmp=va_arg(argptr, _LONGDOUBLE);
/* Note: assumes ch is in ASCII range */
_CLDCVT(&tmp, text.sz, buffersize, (char)ch, precision, capexp);
} else
#endif /* !LONGDOUBLE_IS_DOUBLE */
{
double tmp;
tmp=va_arg(argptr, double);
/* Note: assumes ch is in ASCII range */
/* In safecrt, we provide a special version of _cfltcvt which internally calls printf (see safecrt_output_s.c) */
#ifndef _SAFECRT_IMPL
_cfltcvt_l(&tmp, text.sz, buffersize, (char)ch, precision, capexp, _loc_update.GetLocaleT());
#else /* _SAFECRT_IMPL */
_CFLTCVT(&tmp, text.sz, buffersize, (char)ch, precision, capexp);
#endif /* _SAFECRT_IMPL */
}
#ifndef _SAFECRT_IMPL
/* For safecrt, this is done already in _safecrt_cfltcvt */
/* '#' and precision == 0 means force a decimal point */
if ((flags & FL_ALTERNATE) && precision == 0)
{
_forcdecpt_l(text.sz, _loc_update.GetLocaleT());
}
/* 'g' format means crop zero unless '#' given */
if (ch == L'g' && !(flags & FL_ALTERNATE))
{
_cropzeros_l(text.sz, _loc_update.GetLocaleT());
}
#endif /* _SAFECRT_IMPL */
/* check if result was negative, save '-' for later */
/* and point to positive part (this is for '0' padding) */
if (*text.sz == '-') {
flags |= FL_NEGATIVE;
++text.sz;
}
textlen = (int)strlen(text.sz); /* compute length of text */
}
break;
case L'd':
case L'i':
/* signed decimal output */
flags |= FL_SIGNED;
radix = 10;
goto COMMON_INT;
case L'u':
radix = 10;
goto COMMON_INT;
case L'p':
/* write a pointer -- this is like an integer or long */
/* except we force precision to pad with zeros and */
/* output in big hex. */
precision = 2 * sizeof(void *); /* number of hex digits needed */
#if PTR_IS_INT64
flags |= FL_I64; /* assume we're converting an int64 */
#endif /* !PTR_IS_INT */
/* DROP THROUGH to hex formatting */
case L'X':
/* unsigned upper hex output */
hexadd = L'A' - L'9' - 1; /* set hexadd for uppercase hex */
goto COMMON_HEX;
case L'x':
/* unsigned lower hex output */
hexadd = L'a' - L'9' - 1; /* set hexadd for lowercase hex */
/* DROP THROUGH TO COMMON_HEX */
COMMON_HEX:
radix = 16;
if (flags & FL_ALTERNATE) {
/* alternate form means '0x' prefix */
prefix[0] = L'0';
prefix[1] = (WCHAR)(L'x' - L'a' + L'9' + 1 + hexadd); /* 'x' or 'X' */
prefixlen = 2;
}
goto COMMON_INT;
case L'o':
/* unsigned octal output */
radix = 8;
if (flags & FL_ALTERNATE) {
/* alternate form means force a leading 0 */
flags |= FL_FORCEOCTAL;
}
/* DROP THROUGH to COMMON_INT */
COMMON_INT: {
/* This is the general integer formatting routine. */
/* Basically, we get an argument, make it positive */
/* if necessary, and convert it according to the */
/* correct radix, setting text and textlen */
/* appropriately. */
ULONGLONG number; /* number to convert */
int digit; /* ascii value of digit */
LONGLONG l; /* temp long value */
/* 1. read argument into l, sign extend as needed */
if (flags & FL_I64)
l = va_arg(argptr, LONGLONG);
else if (flags & FL_LONGLONG)
l = va_arg(argptr, LONGLONG);
else
if (flags & FL_SHORT) {
if (flags & FL_SIGNED)
l = (short) va_arg(argptr, int); /* sign extend */
else
l = (unsigned short) va_arg(argptr, int); /* zero-extend*/
} else
{
if (flags & FL_SIGNED)
l = (int)va_arg(argptr, int); /* sign extend */
else
l = (unsigned int) va_arg(argptr, int); /* zero-extend*/
}
/* 2. check for negative; copy into number */
if ( (flags & FL_SIGNED) && l < 0) {
number = -l;
flags |= FL_NEGATIVE; /* remember negative sign */
} else {
number = l;
}
if ( (flags & FL_I64) == 0 && (flags & FL_LONGLONG) == 0 ) {
/*
* Unless printing a full 64-bit value, insure values
* here are not in cananical longword format to prevent
* the sign extended upper 32-bits from being printed.
*/
number &= 0xffffffff;
}
/* 3. check precision value for default; non-default */
/* turns off 0 flag, according to ANSI. */
if (precision < 0)
precision = 1; /* default precision */
else {
flags &= ~FL_LEADZERO;
if (precision > MAXPRECISION)
precision = MAXPRECISION;
}
/* 4. Check if data is 0; if so, turn off hex prefix */
if (number == 0)
prefixlen = 0;
/* 5. Convert data to ASCII -- note if precision is zero */
/* and number is zero, we get no digits at all. */
text.sz = &buffer.sz[BUFFERSIZE-1]; /* last digit at end of buffer */
while (precision-- > 0 || number != 0) {
digit = (int)(number % radix) + '0';
number /= radix; /* reduce number */
if (digit > '9') {
/* a hex digit, make it a letter */
digit += hexadd;
}
*text.sz-- = (char)digit; /* store the digit */
}
textlen = (int)((char *)&buffer.sz[BUFFERSIZE-1] - text.sz); /* compute length of number */
++text.sz; /* text points to first digit now */
/* 6. Force a leading zero if FORCEOCTAL flag set */
if ((flags & FL_FORCEOCTAL) && (textlen == 0 || text.sz[0] != '0')) {
*--text.sz = '0';
++textlen; /* add a zero */
}
}
break;
}
/* At this point, we have done the specific conversion, and */
/* 'text' points to text to print; 'textlen' is length. Now we */
/* justify it, put on prefixes, leading zeros, and then */
/* print it. */
if (!no_output) {
int padding; /* amount of padding, negative means zero */
if (flags & FL_SIGNED) {
if (flags & FL_NEGATIVE) {
/* prefix is a '-' */
prefix[0] = L'-';
prefixlen = 1;
}
else if (flags & FL_SIGN) {
/* prefix is '+' */
prefix[0] = L'+';
prefixlen = 1;
}
else if (flags & FL_SIGNSP) {
/* prefix is ' ' */
prefix[0] = L' ';
prefixlen = 1;
}
}
/* calculate amount of padding -- might be negative, */
/* but this will just mean zero */
padding = fldwidth - textlen - prefixlen;
/* put out the padding, prefix, and text, in the correct order */
if (!(flags & (FL_LEFT | FL_LEADZERO))) {
/* pad on left with blanks */
output->WRITE_MULTI_CHAR(L' ', padding, &charsout);
}
/* write prefix */
output->WRITE_STRING(prefix, prefixlen, &charsout);
if ((flags & FL_LEADZERO) && !(flags & FL_LEFT)) {
/* write leading zeros */
output->WRITE_MULTI_CHAR(L'0', padding, &charsout);
}
/* write text */
if (!bufferiswide && textlen > 0) {
char *p;
int retval, count;
p = text.sz;
count = textlen;
while (count-- > 0) {
#ifdef _SAFECRT_IMPL
retval = _MBTOWC(&wchar, p, MB_CUR_MAX);
#else /* _SAFECRT_IMPL */
retval = _mbtowc_l(&wchar,
p,
_loc_update.GetLocaleT()->locinfo->mb_cur_max,
_loc_update.GetLocaleT());
#endif /* _SAFECRT_IMPL */
if (retval <= 0) {
charsout = -1;
break;
}
output->WRITE_CHAR(wchar, &charsout);
p += retval;
}
} else {
output->WRITE_STRING(text.wz, textlen, &charsout);
}
if (charsout >= 0 && (flags & FL_LEFT)) {
/* pad on right with blanks */
output->WRITE_MULTI_CHAR(L' ', padding, &charsout);
}
/* we're done! */
}
if (heapbuf) {
free(heapbuf);
heapbuf = NULL;
}
break;
}
}
/* The format string shouldn't be incomplete - i.e. when we are finished
with the format string, the last thing we should have encountered
should have been a regular char to be output or a type specifier. Else
the format string was incomplete */
_VALIDATE_RETURN(((state == ST_NORMAL) || (state == ST_TYPE)), EINVAL, -1);
return charsout; /* return value = number of characters written */
}
// Used for holding the size and value of a variable argument.
// Uses INT and LONGLONG to hold all possible values. Each is just a buffer to hold the right number of bits.
struct vararg_t
@ -1944,205 +1240,6 @@ static bool GetFormatMessageArgsA( const char * format, std::vector< vararg_t >
return true;
}
// Caches the var arg values in the supplied vector. Types are determined by inspecting the format string.
// On error, sets errno and returns false
static bool GetFormatMessageArgsW( const WCHAR * format, std::vector< vararg_t > * argcache, va_list * Arguments )
{
if ( NULL == format )
{
errno = EINVAL;
return false;
}
const WCHAR *p = format;
WCHAR fmt_ch;
while( L'\0' != (fmt_ch = *p++) )
{
if ( L'%' != fmt_ch )
{
// continue to next format spec
}
else if ( L'0' == *p || L'\0' == *p )
{
// %0 or null term means end formatting
break;
}
else if ( *p < L'1' || L'9' < *p )
{
// Escaped char, skip and keep going
++p;
}
else
{
// Integer must be [1..99]
size_t argPos = *p++ - L'0';
if ( L'0' <= *p && *p <= L'9' )
{
argPos *= 10;
argPos += *p++ - L'0';
}
assert( 0 < argPos && argPos < 100 );
if ( argcache->size() < argPos )
{
// Haven't processed this arg, yet
argcache->resize( argPos );
}
if ( vararg_t::Unknown == argcache->at(argPos-1).Type() )
{
if ( L'!' != *p )
{
// Assume %s as per spec
argcache->at(argPos-1).SetForPtr();
}
else
{
// Step over the initial '!' and process format specification
++p;
WCHAR ch;
int flags = 0;
int advance = 0;
enum CHARTYPE chclass;
enum STATE state = ST_PERCENT;
bool found_terminator = false;
while ( !found_terminator && (L'\0' != (ch = *p++)) )
{
chclass = GetCharType( ch );
state = GetState( chclass, state );
switch ( state )
{
case ST_DOT:
case ST_FLAG:
break;
case ST_WIDTH:
case ST_PRECIS:
if ( L'*' == ch )
{
argcache->at(argPos-1).SetForInt32();
++argPos;
if ( argcache->size() < argPos )
{
argcache->resize( argPos );
}
}
break;
case ST_SIZE:
state = ProcessSize( ch, p, &advance, &flags );
p += advance;
if ( ST_SIZE != state )
{
// Size and type flags were inconsistent
errno = EINVAL;
return false;
}
break;
case ST_TYPE:
// Group into 32-bit and 64-bit sized args
assert( vararg_t::Unknown == argcache->at(argPos-1).Type() );
switch ( ch )
{
case L'C': // chars
case L'c':
argcache->at(argPos-1).SetForInt32();
break;
case L'd': // ints
case L'i':
case L'u':
case L'X':
case L'x':
case L'o':
// INT args
if ( (flags & FL_I64) || (flags & FL_LONGLONG) )
argcache->at(argPos-1).SetForInt64();
else
argcache->at(argPos-1).SetForInt32();
break;
case L'S': // strings
case L's':
case L'p': // pointer
argcache->at(argPos-1).SetForPtr();
break;
case L'E': // doubles (not supported as per spec)
case L'e':
case L'G':
case L'g':
case L'A':
case L'a':
case L'f':
default:
errno = EINVAL;
return false;
}
break;
case ST_NORMAL:
if ( L'!' == ch )
{
found_terminator = true;
break;
}
// Fall thru to error, missing terminating '!'
default:
errno = EINVAL;
return false;
}
}
if ( !found_terminator )
{
// End of string before trailing '!' was found
errno = EINVAL;
return false;
}
}
}
}
}
if ( 0 < argcache->size() && NULL == Arguments )
{
errno = EINVAL;
return false;
}
// Cache var arg values now that we know the number and sizes
for ( std::vector< vararg_t >::iterator arg = argcache->begin(); arg != argcache->end(); ++arg )
{
if ( vararg_t::Unknown == arg->Type() )
{
// Arg not referenced in format string so assume ptr sized.
// This is a decent assumption since every arg gets ptr-size bytes to ensure alignment
// of later arg values. Verified this behavior with both Windows and Linux.
arg->SetForPtr();
}
vararg_t::ArgType_e argtype = arg->Type();
assert( vararg_t::ShouldBeInt32 == argtype || vararg_t::ShouldBeInt64 == argtype );
if ( vararg_t::ShouldBeInt32 == argtype )
{
arg->Int32Value( (INT)va_arg(*Arguments, INT) );
}
else
{
arg->Int64Value( (LONGLONG)va_arg(*Arguments, LONGLONG) );
}
}
return true;
}
// On success, returns the number of chars written into the buffer excluding null terminator.
// On error, sets errno and returns zero.
static DWORD FormatMessageToBufferA( const char * format, char * buffer, DWORD bufferWCharSize, const std::vector< vararg_t > & args )
@ -2314,178 +1411,6 @@ static DWORD FormatMessageToBufferA( const char * format, char * buffer, DWORD b
return msg_pos;
}
// On success, returns the number of chars written into the buffer excluding null terminator.
// On error, sets errno and returns zero.
static DWORD FormatMessageToBufferW( const WCHAR * format, WCHAR * buffer, DWORD bufferWCharSize, const std::vector< vararg_t > & args )
{
WCHAR * msg = buffer;
DWORD bufsize = std::min(bufferWCharSize, (DWORD)64000);
DWORD msg_pos = 0;
const DWORD fmtsize = 32;
WCHAR fmt[fmtsize];
DWORD fmt_pos;
WCHAR fmt_ch;
const WCHAR * p = format;
while( msg_pos < bufsize && L'\0' != (fmt_ch = *p++) )
{
if ( L'%' != fmt_ch )
{
msg[msg_pos++] = fmt_ch;
}
else if ( L'0' == *p || L'\0' == *p )
{
// %0 or null term means end formatting
break;
}
else if ( *p < L'1' || L'9' < *p )
{
// Escaped char, print and keep going
// Eg. "%n" == '\n'
switch ( *p )
{
case L'a': msg[msg_pos++] = L'\a'; break;
case L'b': msg[msg_pos++] = L'\b'; break;
case L'f': msg[msg_pos++] = L'\f'; break;
case L'n': msg[msg_pos++] = L'\n'; break;
case L'r': msg[msg_pos++] = L'\r'; break;
case L't': msg[msg_pos++] = L'\t'; break;
case L'v': msg[msg_pos++] = L'\v'; break;
default: msg[msg_pos++] = *p; break;
}
++p;
}
else
{
// Integer must be [1..99]
size_t argPos = *p++ - L'0';
if ( L'0' <= *p && *p <= L'9' )
{
argPos *= 10;
argPos += *p++ - L'0';
}
assert( 0 < argPos && argPos < 100 );
fmt_pos = 0;
fmt[fmt_pos++] = L'%';
if ( L'!' != *p )
{
// Assume %s as per spec
fmt[fmt_pos++] = L's';
fmt[fmt_pos] = L'\0';
int chars_printed = mplat_snwprintf_s( &msg[msg_pos], bufsize-msg_pos, bufsize-msg_pos, fmt, args[argPos-1].PtrValue() );
if ( chars_printed < 0 )
{
errno = EINVAL;
return 0;
}
msg_pos += chars_printed;
}
else
{
// Skip over '!' and build format string
++p;
WCHAR ch;
int flags = 0;
int advance = 0;
enum CHARTYPE chclass;
enum STATE state = ST_PERCENT;
bool found_terminator = false;
while ( fmt_pos < fmtsize && !found_terminator && (L'\0' != (ch = *p++)) )
{
chclass = GetCharType( ch );
state = GetState( chclass, state );
switch ( state )
{
case ST_SIZE:
state = ProcessSize( ch, p, &advance, &flags );
fmt[fmt_pos++] = ch;
while ( fmt_pos < fmtsize && 0 < advance-- )
{
fmt[fmt_pos++] = *p++;
}
break;
case ST_NORMAL:
assert( L'!' == ch );
found_terminator = true;
break;
case ST_INVALID:
case ST_PERCENT:
errno = EINVAL;
return 0;
default:
fmt[fmt_pos++] = ch;
break;
}
}
if ( fmtsize <= fmt_pos )
{
// Should not have a format string longer than 31 chars
// It can happen but shouldn't (eg. a bunch of size mods like %llllllllllllllld)
errno = EINVAL;
return 0;
}
fmt[fmt_pos] = L'\0';
// Format string might need up to 3 args (eg. %*.*d )
// If more than one arg, then the first ones must be 32-bit ints
// Hence, first 64-bit arg tells us the last arg we need to send.
int chars_printed = 0;
if ( vararg_t::Int64 == args[argPos-1].Type() )
{
chars_printed = mplat_snwprintf_s( &msg[msg_pos], bufsize-msg_pos, bufsize-msg_pos, fmt, args[argPos-1].Int64Value() );
}
else if ( args.size() == argPos )
{
// No more args so send the one Int
chars_printed = mplat_snwprintf_s( &msg[msg_pos], bufsize-msg_pos, bufsize-msg_pos, fmt, args[argPos-1].Int32Value() );
}
else if ( vararg_t::Int64 == args[argPos].Type() )
{
chars_printed = mplat_snwprintf_s( &msg[msg_pos], bufsize-msg_pos, bufsize-msg_pos, fmt, args[argPos-1].Int32Value(), args[argPos].Int64Value() );
}
else if ( args.size() == (argPos+1) )
{
// No more args so send the two Ints
chars_printed = mplat_snwprintf_s( &msg[msg_pos], bufsize-msg_pos, bufsize-msg_pos, fmt, args[argPos-1].Int32Value(), args[argPos-1].Int32Value() );
}
else if ( vararg_t::Int64 == args[argPos+1].Type() )
{
chars_printed = mplat_snwprintf_s( &msg[msg_pos], bufsize-msg_pos, bufsize-msg_pos, fmt, args[argPos-1].Int32Value(), args[argPos].Int32Value(), args[argPos+1].Int64Value() );
}
else
{
chars_printed = mplat_snwprintf_s( &msg[msg_pos], bufsize-msg_pos, bufsize-msg_pos, fmt, args[argPos-1].Int32Value(), args[argPos].Int32Value(), args[argPos+1].Int32Value() );
}
if ( chars_printed < 0 )
{
errno = EINVAL;
return 0;
}
msg_pos += chars_printed;
}
}
}
if ( bufsize <= msg_pos )
{
errno = ERANGE;
return 0;
}
msg[msg_pos] = L'\0';
return msg_pos;
}
DWORD FormatMessageA(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPTSTR lpBuffer, DWORD nSize, va_list *Arguments)
{
DWORD chars_printed = 0;
@ -2596,96 +1521,6 @@ DWORD FormatMessageA(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD d
//
// dwLanguageId is ignored for FORMAT_MESSAGE_FROM_STRING as per spec
// For FORMAT_MESSAGE_FROM_SYSTEM, we don't have Windows resources so language is irrelevant
DWORD FormatMessageW(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPWSTR lpBuffer, DWORD nSize, va_list *Arguments)
{
DWORD chars_printed = 0;
// XPLAT_ODBC_TODO VSTS 718708 Localization by handling FORMAT_MESSAGE_FROM_HMODULE and dwLanguageId param
if ( dwFlags & FORMAT_MESSAGE_FROM_STRING )
{
// Format specification allows for reordering of insertions relative to var arg position
// This means we need to walk thru the format specification to find the types of the var args in var arg order
// We extract the var args in order based on the identified types
// Finally, we re-walk the format specfication and perform the insertions
// First pass thru the format string to determine all args and their types
// This first pass also validates the format string and will return an error
// if it is invalid. This allows FormatMessageToBuffer to have less error
// checking.
std::vector< vararg_t > args;
// Based on quick scan of RC files, the largest arg count was 7 so reserve 8 slots to reduce allocations
args.reserve(8);
if ( GetFormatMessageArgsW( reinterpret_cast<const WCHAR *>(lpSource), &args, Arguments ) )
{
if ( dwFlags == (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING) )
{
*((WCHAR**)lpBuffer) = NULL;
const DWORD max_size = 64000;
WCHAR local_buf[max_size];
chars_printed = FormatMessageToBufferW( reinterpret_cast<const WCHAR *>(lpSource), local_buf, max_size, args );
if ( 0 < chars_printed )
{
size_t buf_size = std::min( max_size, std::max(nSize, (chars_printed+1)) );
WCHAR * return_buf = (WCHAR *)LocalAlloc(0, buf_size * sizeof(WCHAR));
if ( NULL == return_buf )
{
errno = ENOMEM;
}
else
{
mplat_wcscpy(return_buf, local_buf);
*((WCHAR**)lpBuffer) = return_buf;
}
}
}
else if ( dwFlags == FORMAT_MESSAGE_FROM_STRING )
{
chars_printed = FormatMessageToBufferW( reinterpret_cast<const WCHAR *>(lpSource), lpBuffer, std::min(nSize, (DWORD)64000), args );
}
}
}
else if ( dwFlags & FORMAT_MESSAGE_FROM_SYSTEM )
{
// Since we don't have the Windows system error messages available use a fixed message
// Can not use a message ID for this since this same code is used by driver and tools,
// each having their own RLL file. Don't think we should be reserving an ID across all RLLs.
const wchar_t systemMsg[] = L"Error code 0x%X";
if ( dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER )
{
*((WCHAR**)lpBuffer) = NULL;
// Add 9 for up to 8 hex digits plus null term (ignore removal of format specs)
const size_t msgsize = (9 + sizeof(systemMsg)/sizeof(systemMsg[0]));
WCHAR * return_buf = (WCHAR *)LocalAlloc(0, msgsize * sizeof(WCHAR));
if ( NULL == return_buf )
{
errno = ENOMEM;
}
else
{
chars_printed = mplat_snwprintf_s( return_buf, msgsize, msgsize, (WCHAR *)systemMsg, dwMessageId );
// Assert that we did our buffer size math right
assert( chars_printed < msgsize );
if ( 0 < chars_printed )
{
*((WCHAR**)lpBuffer) = return_buf;
}
else
{
LocalFree( return_buf );
errno = EINVAL;
}
}
}
else
{
chars_printed = mplat_snwprintf_s( lpBuffer, nSize, nSize, (WCHAR *)systemMsg, dwMessageId );
}
}
return chars_printed;
}
//--------Other definitions from xplat stub sources--------------
@ -2730,21 +1565,6 @@ BOOL IsDBCSLeadByteEx(
return TRUE;
}
int mplat_vsnwprintf( WCHAR * buffer, size_t count, const WCHAR * format, va_list args )
{
BufferOutput<WCHAR> output( buffer, count );
return FormattedPrintW( &output, format, args );
}
int mplat_snwprintf_s( WCHAR *buffer, size_t bufsize, size_t count, const WCHAR *format, ... )
{
va_list args;
va_start( args, format );
int retcode = mplat_vsnwprintf( buffer, std::min(bufsize, count), format, args );
va_end( args );
return retcode;
}
int mplat_vsnprintf( char * buffer, size_t count, const char * format, va_list args )
{
BufferOutput<char> output( buffer, count );
@ -2760,17 +1580,6 @@ int mplat_snprintf_s( char *buffer, size_t bufsize, size_t count, const char *fo
return retcode;
}
// Tools\vc\src\crt\amd64\wcscat.c
WCHAR * mplat_wcscpy( WCHAR * dst, const WCHAR * src )
{
WCHAR * cp = dst;
while( (*cp++ = *src++) )
; /* Copy src over dst */
return( dst );
}
char * mplat_cscpy( char * dst, const char * src )
{
char * cp = dst;

7
source/shared/FormattedPrint.h
View file

@ -24,12 +24,6 @@
#include "xplat_winnls.h"
#include "localization.hpp"
inline bool __ascii_iswalpha(WCHAR c) { return( ('A' <= (c) && (c) <= 'Z') || ( 'a' <= (c) && (c) <= 'z') ); }
inline WCHAR __ascii_towupper(WCHAR c) { return( (((c) >= L'a') && ((c) <= L'z')) ? (WCHAR)((c) - L'a' + L'A') : (c) ); }
inline char __ascii_toupper(char c) { return( (((c) >= 'a') && ((c) <= 'z')) ? ((c) - 'a' + 'A') : (c) ); }
template< typename T >
struct IFormattedPrintOutput
@ -73,7 +67,6 @@ protected:
};
int FormattedPrintA( IFormattedPrintOutput<char> * output, const char *format, va_list argptr );
int FormattedPrintW( IFormattedPrintOutput<WCHAR> * output, const WCHAR *format, va_list argptr );
template< typename T >
class BufferOutput : public FormattedOutput<T>

20
source/shared/interlockedatomic.h
View file

@ -24,30 +24,10 @@
// Forward references and contract specifications
//
// Increments and returns new value
LONG InterlockedIncrement( LONG volatile * atomic );
// Decrements and returns new value
LONG InterlockedDecrement( LONG volatile * atomic );
// Always returns old value
// Sets to new value if old value equals compareTo
LONG InterlockedCompareExchange( LONG volatile * atomic, LONG newValue, LONG compareTo );
// Sets to new value and returns old value
LONG InterlockedExchange( LONG volatile * atomic, LONG newValue );
// Sets to new value and returns old value
PVOID InterlockedExchangePointer( PVOID volatile * atomic, PVOID newValue);
// Adds the amount and returns the old value
LONG InterlockedExchangeAdd( LONG volatile * atomic, LONG add );
// Always returns the old value
// Sets the new value if old value equals compareTo
PVOID InterlockedCompareExchangePointer( PVOID volatile * atomic, PVOID newValue, PVOID compareTo );
// Use conditional compilation to load the implementation
//

30
source/shared/interlockedatomic_gcc.h
View file

@ -25,39 +25,9 @@
#error "Incorrect compiler configuration in InterlockedAtomic.h. Was expecting GCC."
#endif
inline LONG InterlockedIncrement( LONG volatile * atomic )
{
return __sync_add_and_fetch( atomic, 1 );
}
inline LONG InterlockedDecrement( LONG volatile * atomic )
{
return __sync_sub_and_fetch( atomic, 1 );
}
inline LONG InterlockedCompareExchange( LONG volatile * atomic, LONG newValue, LONG compareTo )
{
return __sync_val_compare_and_swap( atomic, compareTo, newValue );
}
inline LONG InterlockedExchange( LONG volatile * atomic, LONG newValue )
{
return __sync_lock_test_and_set( atomic, newValue );
}
inline PVOID InterlockedExchangePointer( PVOID volatile * atomic, PVOID newValue)
{
return __sync_lock_test_and_set( atomic, newValue );
}
inline LONG InterlockedExchangeAdd( LONG volatile * atomic, LONG add )
{
return __sync_fetch_and_add( atomic, add );
}
inline PVOID InterlockedCompareExchangePointer( PVOID volatile * atomic, PVOID newValue, PVOID compareTo )
{
return __sync_val_compare_and_swap( atomic, compareTo, newValue );
}
#endif // __INTERLOCKEDATOMIC_GCC_H__

526
source/shared/localization.hpp
View file

@ -110,23 +110,6 @@ struct AutoArray
m_cchSize = 0;
return oldPtr;
}
void UpdateSize()
{
if ( NULL == m_ptr )
{
m_cchSize = 0;
}
else
{
// XPLAT_ODBC_TODO VSTS 819733 MPlat: Reconcile std c++ usage between platforms
// Should use char_traits<ArrayT>::length
ArrayT * end = m_ptr;
while ( (ArrayT)0 != *end++ )
;
// Want the null terminator included
m_cchSize = end - m_ptr;
}
}
};
@ -143,130 +126,12 @@ public:
#endif
#ifdef MPLAT_UNIX
int GetResourcePath( char * buffer, size_t cchBuffer ) const;
static const int MINS_PER_HOUR = 60;
static const int MINS_PER_DAY = 24 * MINS_PER_HOUR;
// Returns the bias between the supplied utc and local times.
// utc = local + bias
static int BiasInMinutes( const struct tm & utc, const struct tm & local )
{
int bias = 0;
if ( utc.tm_mon != local.tm_mon )
{
// Offset crosses month boundary so one of two must be first day of month
if ( 1 == utc.tm_mday )
bias += MINS_PER_DAY;
else
{
assert( 1 == local.tm_mday );
bias -= MINS_PER_DAY;
}
}
else
{
bias += MINS_PER_DAY * (utc.tm_mday - local.tm_mday);
}
bias += MINS_PER_HOUR * (utc.tm_hour - local.tm_hour);
bias += (utc.tm_min - local.tm_min);
// Round based on diff in secs, in case utc/local straddle a day with leap seconds
int secs_diff = (utc.tm_sec - local.tm_sec);
if ( 29 < secs_diff )
++bias;
else if ( secs_diff < -29 )
--bias;
return bias;
}
// Returns both standard and daylight savings biases for the current year
// utc = local + bias
// Both might be equal if DST is not honored
// If platform doesn't know if bias is DST or standard (ie. unknown)
// then standard time is assumed.
// Note that applying current year's biases to dates from other years may result
// in incorrect time adjustments since regions change their rules over time.
// The current SNAC driver code uses this approach as well so we are doing this
// to preserve consistent behavior. If SNAC changes to lookup the offsets that
// were effective for a given date then we should update our logic here as well.
static DWORD TimeZoneBiases( int * stdInMinutes, int * dstInMinutes )
{
struct tm local, utc;
// Find current year
time_t now = time( NULL );
if ( (time_t)(-1) == now || NULL == localtime_r(&now, &local) )
return ERROR_INVALID_DATA;
// Find bias for first of each month until both STD and DST are found
// Possible perf improvements (can wait until perf tests indicate a need):
// Just use Dec 21 and Jun 21 (near the two soltices)
// Or calc once and cache (must be thread safe)
bool foundUNK = false;
bool foundSTD = false;
bool foundDST = false;
int std_bias = 0;
int dst_bias = 0;
local.tm_mday = 1;
for ( int mon = 0; mon < 12; ++mon )
{
local.tm_mon = mon;
if ( (time_t)(-1) == (now = mktime(&local)) || NULL == gmtime_r(&now, &utc) )
return ERROR_INVALID_DATA;
if ( 0 < local.tm_isdst )
{
if ( !foundDST )
{
dst_bias = BiasInMinutes( utc, local );
foundDST = true;
if ( foundSTD )
break; // Done checking when both STD & DST are found
}
}
else
{
// Time is STD or unknown, put in STD
if ( !foundSTD )
{
std_bias = BiasInMinutes( utc, local );
if ( local.tm_isdst < 0 )
foundUNK = true;
else
{
foundSTD = true;
if ( foundDST )
break; // Done checking when both STD and DST are found
}
}
}
}
// At least one of STD, DST, or unknown must have been set
assert( foundSTD || foundDST || foundUNK );
// For zones that don't observe DST (somewhat common),
// report DST bias as the same as STD
if ( !foundDST )
dst_bias = std_bias;
// For zones that ONLY observe DST (extremely rare if at all),
// report STD bias as the same as DST
if ( !foundSTD && !foundUNK )
std_bias = dst_bias;
*stdInMinutes = std_bias;
*dstInMinutes = dst_bias;
return ERROR_SUCCESS;
}
#endif
static DWORD CurrentLocalTime( LPSYSTEMTIME pTime );
// Multi-byte UTF8 code points start with '11xx xxxx'
static bool IsUtf8LeadByte( BYTE utf8 )
{
@ -291,43 +156,11 @@ public:
// Given the start byte, how many total bytes are expected for
// this code point. If start is a UTF8 trail byte, then 1 is returned.
static UINT CchExpectedNextChar( UINT codepage, BYTE start )
{
if ( 0 == (start & (char)0x80) )
return 1; // ASCII
else if ( CP_UTF8 == codepage )
return IsUtf8LeadByte(start) ? CchUtf8CodePt(start) : 1;
else if ( IsDBCSLeadByteEx(codepage, start) )
return 2;
else
return 1;
}
// Returns the number of bytes that need to be trimmed to avoid splitting
// a multi-byte code point sequence at the end of the buffer.
// Returns zero if a trailing UTF8 code value is found but no
// matching lead byte was found for it (ie. invalid, dangling trail byte).
_Ret_range_(0, cchBuffer) static UINT TrimPartialCodePt( UINT codepage, _In_count_(cchBuffer) const BYTE * buffer, size_t cchBuffer )
{
if ( 0 == cchBuffer )
return 0;
if ( CP_UTF8 == codepage )
{
return TrimPartialUtf8CodePt( buffer, cchBuffer );
}
else
{
size_t i = cchBuffer;
for ( ; 0 < i; --i )
{
if ( !IsDBCSLeadByteEx( codepage, buffer[i-1] ) )
break;
}
// If odd, then last byte is truly a lead byte so return 1 byte to trim
return ((cchBuffer-i) & 1) ? 1 : 0;
}
}
// For all transcoding functions
// Returns zero on error. Do not call GetLastError() since that is not portable (pErrorCode has result of GetLastError()).
@ -336,74 +169,26 @@ public:
// Transcode between a code page and UTF16
static size_t ToUtf16( UINT srcCodePage, const char * src, SSIZE_T cchSrc,
__out_ecount_opt(cchDest) WCHAR * dest, size_t cchDest,
DWORD * pErrorCode = NULL );
__out_ecount_opt(cchDest) WCHAR * dest, size_t cchDest,
DWORD * pErrorCode = NULL );
static size_t ToUtf16Strict( UINT srcCodePage, const char * src, SSIZE_T cchSrc,
__out_ecount_opt(cchDest) WCHAR * dest, size_t cchDest,
DWORD * pErrorCode = NULL );
__out_ecount_opt(cchDest) WCHAR * dest, size_t cchDest,
DWORD * pErrorCode = NULL );
static size_t FromUtf16( UINT destCodePage, const WCHAR * src, SSIZE_T cchSrc,
__out_ecount_opt(cchDest) char * dest, size_t cchDest,
bool * pHasDataLoss = NULL, DWORD * pErrorCode = NULL );
static size_t FromUtf16Strict(UINT destCodePage, const WCHAR * src, SSIZE_T cchSrc,
__out_ecount_opt(cchDest) char * dest, size_t cchDest,
bool * pHasDataLoss = NULL, DWORD * pErrorCode = NULL);
// Allocates destination buffer to match required size
// Template is used so call can provide allocation policy
// Used instead of the Windows API pattern of calling with zero dest buffer size to find
// required buffer size, followed by second call with newly allocated buffer.
template< typename AllocT >
static size_t ToUtf16( UINT srcCodePage, const char * src, SSIZE_T cchSrc, __deref_out_ecount(1) WCHAR ** dest, DWORD * pErrorCode = NULL );
template< typename AllocT >
static size_t ToUtf16Strict( UINT srcCodePage, const char * src, SSIZE_T cchSrc, __deref_out_ecount(1) WCHAR ** dest, DWORD * pErrorCode = NULL );
template< typename AllocT >
static size_t FromUtf16( UINT destCodePage, const WCHAR * src, SSIZE_T cchSrc, __deref_out_ecount(1) char ** dest, bool * pHasDataLoss = NULL, DWORD * pErrorCode = NULL );
template< typename AllocT >
static size_t FromUtf16Strict(UINT destCodePage, const WCHAR * src, SSIZE_T cchSrc, __deref_out_ecount(1) char ** dest, bool * pHasDataLoss = NULL, DWORD * pErrorCode = NULL);
__out_ecount_opt(cchDest) char * dest, size_t cchDest,
bool * pHasDataLoss = NULL, DWORD * pErrorCode = NULL );
static size_t FromUtf16Strict(UINT destCodePage, const WCHAR * src, SSIZE_T cchSrc,
__out_ecount_opt(cchDest) char * dest, size_t cchDest,
bool * pHasDataLoss = NULL, DWORD * pErrorCode = NULL);
// -----------------------------------------------------------------------
// Public Member Functions
#ifndef TIME_ZONE_ID_UNKNOWN
#define TIME_ZONE_ID_UNKNOWN 0
#define TIME_ZONE_ID_STANDARD 1
#define TIME_ZONE_ID_DAYLIGHT 2
#endif
// pTZInfo, if supplied, holds one of the above defined values
DWORD CurrentTimeZoneBias( LONG * offsetInMinutes, DWORD * pTZInfo = NULL ) const;
// The Ansi code page, always UTF8 for Linux
UINT AnsiCP() const;
// Used for files (e.g. returns 437 on US Windows, UTF8 for Linux)
UINT OemCP() const;
// Returns UTF-16LE for all platforms (LE == Little Endian)
UINT WideCP() const
{
return CP_UTF16;
}
// Performs case folding to lower case using the current system locale
// Replaces calls to LCMapStringA
size_t ToLower( const char * src, SSIZE_T cchSrc, __out_ecount_opt(cchDest) char * dest, size_t cchDest, DWORD * pErrorCode = NULL ) const;
#ifndef CSTR_ERROR
#define CSTR_ERROR 0 // compare failed
#define CSTR_LESS_THAN 1 // string 1 less than string 2
#define CSTR_EQUAL 2 // string 1 equal to string 2
#define CSTR_GREATER_THAN 3 // string 1 greater than string 2
#endif
// String comparison using the rules of the current system locale.
// Replaces calls to CompareString
// Ignoring width (Bing for "Full Width Characters") has no affect on Linux
// Return value is one of the above defined values.
// On error, pErrorCode has result of GetLastError() (do not call GetLastError directly since it isn't portable).
int Compare( const char * left, SSIZE_T cchLeft, const char * right, SSIZE_T cchRight, DWORD * pErrorCode = NULL ) const;
int CompareIgnoreCase( const char * left, SSIZE_T cchLeft, const char * right, SSIZE_T cchRight, DWORD * pErrorCode = NULL ) const;
int CompareIgnoreWidth( const char * left, SSIZE_T cchLeft, const char * right, SSIZE_T cchRight, DWORD * pErrorCode = NULL ) const;
int CompareIgnoreCaseAndWidth( const char * left, SSIZE_T cchLeft, const char * right, SSIZE_T cchRight, DWORD * pErrorCode = NULL ) const;
private:
@ -447,8 +232,6 @@ private:
return static_cast<size_t>(cch);
}
static int CompareWithFlags( DWORD flags, const char * left, SSIZE_T cchLeft, const char * right, SSIZE_T cchRight, DWORD * pErrorCode = NULL );
static size_t FastAsciiMultiByteToWideChar
(
UINT CodePage,
@ -492,90 +275,9 @@ private:
return expected_size;
}
// Returns the number of bytes that need to be trimmed to avoid splitting
// a UTF8 code point sequence at the end of the buffer.
// Returns zero for ASCII.
// Also returns zero if a trailing UTF8 code value is found but no
// matching lead byte was found for it (ie. invalid, dangling trail byte).
static UINT TrimPartialUtf8CodePt( const BYTE * buffer, size_t cchBuffer )
{
if ( 0 == cchBuffer )
return 0;
if ( 0 == (buffer[cchBuffer-1] & 0x80) )
{
// Last char is ASCII so no trim needed
return 0;
}
// Last char is non-initial byte of multibyte utf8 sequence
// Need to determine if it is the last (ie. no trim need)
UINT cchMax = MaxCharCchSize( CP_UTF8 );
for ( UINT i = 1; 0 < cchBuffer && i <= cchMax; --cchBuffer, ++i )
{
if ( IsUtf8LeadByte(buffer[cchBuffer-1]) )
{
// Found initial byte, verify size of sequence
UINT cchExpected = CchUtf8CodePt( buffer[cchBuffer-1] );
if ( i == cchExpected )
return 0; // utf8 sequence is complete so no trim needed
else
{
assert( i <= cchBuffer );
return i; // trim the incomplete sequence
}
}
}
// Did not find initial utf8 byte so trim nothing
return 0;
}
};
// Convenience wrapper for converting from UTF16 into a newly
// allocated char[]. Class behaves like auto_ptr (will free in dtor,
// but has Release method so caller can take ownership of memory).
template< typename AllocT = ArrayTAllocator< char > >
struct AutoCharArray : public AutoArray< char, AllocT >
{
size_t AllocConvertFromUtf16( UINT destCodePage, const WCHAR * src, SSIZE_T cchSrc, bool * pHasDataLoss = NULL, DWORD * pErrorCode = NULL )
{
char * converted = NULL;
size_t cchCvt = SystemLocale::FromUtf16< AllocT >( destCodePage, src, cchSrc, &converted, pHasDataLoss, pErrorCode );
if ( 0 < cchCvt )
{
this->Free();
this->m_ptr = converted;
this->m_cchSize = cchCvt;
}
return cchCvt;
}
};
// Convenience wrapper for converting to UTF16 into a newly
// allocated WCHAR[]. Class behaves like auto_ptr (will free in dtor,
// but has Release method so caller can take ownership of memory).
template< typename AllocT = ArrayTAllocator< WCHAR > >
struct AutoWCharArray : public AutoArray< WCHAR, AllocT >
{
size_t AllocConvertToUtf16( UINT destCodePage, const char * src, SSIZE_T cchSrc, bool * pHasDataLoss = NULL, DWORD * pErrorCode = NULL )
{
WCHAR * converted = NULL;
size_t cchCvt = SystemLocale::ToUtf16< AllocT >( destCodePage, src, cchSrc, &converted, pErrorCode );
if ( 0 < cchCvt )
{
this->Free();
this->m_ptr = converted;
this->m_cchSize = cchCvt;
}
return cchCvt;
}
};
// ---------------------------------------------------------------------------
// Inlines that vary by platform
@ -589,11 +291,6 @@ inline UINT SystemLocale::AnsiCP() const
return CP_UTF8;
}
inline UINT SystemLocale::OemCP() const
{
return CP_UTF8;
}
inline UINT SystemLocale::MaxCharCchSize( UINT codepage )
{
codepage = ExpandSpecialCP( codepage );
@ -612,67 +309,6 @@ inline UINT SystemLocale::MaxCharCchSize( UINT codepage )
}
}
inline int SystemLocale::CompareIgnoreWidth( const char * left, SSIZE_T cchLeft, const char * right, SSIZE_T cchRight, DWORD * pErrorCode ) const
{
// XPLAT_ODBC_TODO: VSTS 806013 MPLAT: Support IgnoreWidth for SNI string comparisons
return Compare( left, cchLeft, right, cchRight, pErrorCode );
}
inline int SystemLocale::CompareIgnoreCaseAndWidth( const char * left, SSIZE_T cchLeft, const char * right, SSIZE_T cchRight, DWORD * pErrorCode ) const
{
// XPLAT_ODBC_TODO: VSTS 806013 MPLAT: Support IgnoreWidth for SNI string comparisons
return CompareIgnoreCase( left, cchLeft, right, cchRight, pErrorCode );
}
template< typename AllocT >
inline size_t SystemLocale::ToUtf16( UINT srcCodePage, const char * src, SSIZE_T cchSrc, WCHAR ** dest, DWORD * pErrorCode )
{
srcCodePage = ExpandSpecialCP( srcCodePage );
EncodingConverter cvt( CP_UTF16, srcCodePage );
if ( !cvt.Initialize() )
{
if ( NULL != pErrorCode )
*pErrorCode = ERROR_INVALID_PARAMETER;
return 0;
}
size_t cchSrcActual = (cchSrc < 0 ? (1+strlen(src)) : cchSrc);
bool hasLoss;
return cvt.Convert< WCHAR, char, AllocT >( dest, src, cchSrcActual, false, &hasLoss, pErrorCode );
}
template< typename AllocT >
inline size_t SystemLocale::ToUtf16Strict( UINT srcCodePage, const char * src, SSIZE_T cchSrc, WCHAR ** dest, DWORD * pErrorCode )
{
srcCodePage = ExpandSpecialCP( srcCodePage );
EncodingConverter cvt( CP_UTF16, srcCodePage );
if ( !cvt.Initialize() )
{
if ( NULL != pErrorCode )
*pErrorCode = ERROR_INVALID_PARAMETER;
return 0;
}
size_t cchSrcActual = (cchSrc < 0 ? (1+strlen(src)) : cchSrc);
bool hasLoss;
return cvt.Convert< WCHAR, char, AllocT >( dest, src, cchSrcActual, true, &hasLoss, pErrorCode );
}
template< typename AllocT >
inline size_t SystemLocale::FromUtf16( UINT destCodePage, const WCHAR * src, SSIZE_T cchSrc, char ** dest, bool * pHasDataLoss, DWORD * pErrorCode )
{
destCodePage = ExpandSpecialCP( destCodePage );
EncodingConverter cvt( destCodePage, CP_UTF16 );
if ( !cvt.Initialize() )
{
if ( NULL != pErrorCode )
*pErrorCode = ERROR_INVALID_PARAMETER;
return 0;
}
size_t cchSrcActual = (cchSrc < 0 ? (1+mplat_wcslen(src)) : cchSrc);
bool hasLoss;
return cvt.Convert< char, WCHAR, AllocT >( dest, src, cchSrcActual, false, &hasLoss, pErrorCode );
}
// MPLAT_UNIX ----------------------------------------------------------------
#else
// ! MPLAT_UNIX ----------------------------------------------------------------
@ -687,40 +323,11 @@ inline const SystemLocale SystemLocale::Singleton()
return SystemLocale();
}
inline DWORD SystemLocale::CurrentTimeZoneBias( LONG * offsetInMinutes, DWORD * pTZInfo ) const
{
TIME_ZONE_INFORMATION tzi;
DWORD tzInfo;
if ( NULL == offsetInMinutes )
return ERROR_INVALID_PARAMETER;
else if ( TIME_ZONE_ID_INVALID == (tzInfo = GetTimeZoneInformation(&tzi)) )
return GetLastError();
else
{
*offsetInMinutes = tzi.Bias;
if ( NULL != pTZInfo )
*pTZInfo = tzInfo;
return ERROR_SUCCESS;
}
}
inline DWORD SystemLocale::CurrentLocalTime( LPSYSTEMTIME pTime )
{
GetLocalTime( pTime );
return ERROR_SUCCESS;
}
inline UINT SystemLocale::AnsiCP() const
{
return GetACP();
}
inline UINT SystemLocale::OemCP() const
{
return GetOEMCP();
}
inline UINT SystemLocale::MaxCharCchSize( UINT codepage )
{
CPINFO cpinfo;
@ -728,74 +335,6 @@ inline UINT SystemLocale::MaxCharCchSize( UINT codepage )
return (rc ? cpinfo.MaxCharSize : 0);
}
inline size_t SystemLocale::ToLower( const char * src, SSIZE_T cchSrc, char * dest, size_t cchDest, DWORD * pErrorCode ) const
{
// Windows API takes 'int' sized parameters
if ( cchSrc < -1 || 0x7FFFFFF < cchSrc || 0x7FFFFFF < cchDest )
{
if ( NULL != pErrorCode )
*pErrorCode = ERROR_INVALID_PARAMETER;
return 0;
}
OACR_WARNING_PUSH
OACR_WARNING_DISABLE(SYSTEM_LOCALE_MISUSE , " INTERNATIONALIZATION BASELINE AT KATMAI RTM. FUTURE ANALYSIS INTENDED. ")
OACR_WARNING_DISABLE(ANSI_APICALL, " Keeping the ANSI API for now. ")
int cch = LCMapStringA(
LOCALE_SYSTEM_DEFAULT,
LCMAP_LOWERCASE,
src,
(int)cchSrc,
dest,
(int)cchDest );
OACR_WARNING_POP
return ReturnCchResult( cch, pErrorCode );
}
inline int SystemLocale::CompareWithFlags( DWORD flags, const char * left, SSIZE_T cchLeft, const char * right, SSIZE_T cchRight, DWORD * pErrorCode )
{
// Windows API takes 'int' sized parameters
if ( cchLeft < -1 || 0x7FFFFFF < cchLeft || cchRight < -1 || 0x7FFFFFF < cchRight )
{
if ( NULL != pErrorCode )
*pErrorCode = ERROR_INVALID_PARAMETER;
return 0;
}
OACR_WARNING_PUSH
OACR_WARNING_DISABLE(SYSTEM_LOCALE_MISUSE , " INTERNATIONALIZATION BASELINE AT KATMAI RTM. FUTURE ANALYSIS INTENDED. ")
int cmp = CompareStringA( LOCALE_SYSTEM_DEFAULT, flags, left, (int)cchLeft, right, (int)cchRight );
OACR_WARNING_POP
if ( NULL != pErrorCode )
{
*pErrorCode = (CSTR_ERROR == cmp ? GetLastError() : ERROR_SUCCESS);
}
return cmp;
}
inline int SystemLocale::Compare( const char * left, SSIZE_T cchLeft, const char * right, SSIZE_T cchRight, DWORD * pErrorCode ) const
{
return CompareWithFlags( 0, left, cchLeft, right, cchRight, pErrorCode );
}
inline int SystemLocale::CompareIgnoreCase( const char * left, SSIZE_T cchLeft, const char * right, SSIZE_T cchRight, DWORD * pErrorCode ) const
{
return CompareWithFlags( NORM_IGNORECASE, left, cchLeft, right, cchRight, pErrorCode );
}
inline int SystemLocale::CompareIgnoreCaseAndWidth( const char * left, SSIZE_T cchLeft, const char * right, SSIZE_T cchRight, DWORD * pErrorCode ) const
{
return CompareWithFlags( NORM_IGNORECASE|NORM_IGNOREWIDTH, left, cchLeft, right, cchRight, pErrorCode );
}
inline int SystemLocale::CompareIgnoreWidth( const char * left, SSIZE_T cchLeft, const char * right, SSIZE_T cchRight, DWORD * pErrorCode ) const
{
return CompareWithFlags( NORM_IGNOREWIDTH, left, cchLeft, right, cchRight, pErrorCode );
}
inline char * SystemLocale::NextChar( UINT codepage, const char * start )
{
return CharNextExA( (WORD)codepage, start, 0 );
@ -822,53 +361,6 @@ inline size_t SystemLocale::FromUtf16( UINT destCodePage, const WCHAR * src, SSI
return cchCvt;
}
template< typename AllocT >
inline size_t SystemLocale::ToUtf16( UINT srcCodePage, const char * src, SSIZE_T cchSrc, WCHAR ** dest, DWORD * pErrorCode )
{
size_t cchCvt = FastAsciiMultiByteToWideChar( srcCodePage, src, cchSrc, NULL, 0, pErrorCode );
if ( 0 < cchCvt )
{
AutoArray< WCHAR, AllocT > newDestBuffer( cchCvt );
cchCvt = FastAsciiMultiByteToWideChar( srcCodePage, src, cchSrc, newDestBuffer.m_ptr, cchCvt, pErrorCode );
if ( 0 < cchCvt )
*dest = newDestBuffer.Detach();
}
return cchCvt;
}
template< typename AllocT >
inline size_t SystemLocale::ToUtf16Strict( UINT srcCodePage, const char * src, SSIZE_T cchSrc, WCHAR ** dest, DWORD * pErrorCode )
{
size_t cchCvt = FastAsciiMultiByteToWideChar( srcCodePage, src, cchSrc, NULL, 0, pErrorCode, true );
if ( 0 < cchCvt )
{
AutoArray< WCHAR, AllocT > newDestBuffer( cchCvt );
cchCvt = FastAsciiMultiByteToWideChar( srcCodePage, src, cchSrc, newDestBuffer.m_ptr, cchCvt, pErrorCode, true );
if ( 0 < cchCvt )
*dest = newDestBuffer.Detach();
}
return cchCvt;
}
template< typename AllocT >
inline size_t SystemLocale::FromUtf16( UINT destCodePage, const WCHAR * src, SSIZE_T cchSrc, char ** dest, bool * pHasDataLoss, DWORD * pErrorCode )
{
BOOL dataloss = FALSE;
size_t cchCvt = FastAsciiWideCharToMultiByte( destCodePage, src, cchSrc, NULL, 0, &dataloss, pErrorCode );
if ( 0 < cchCvt )
{
AutoArray< char, AllocT > newDestBuffer( cchCvt );
cchCvt = FastAsciiWideCharToMultiByte( destCodePage, src, cchSrc, newDestBuffer.m_ptr, cchCvt, &dataloss, pErrorCode );
if ( 0 < cchCvt )
*dest = newDestBuffer.Detach();
}
if ( NULL != pHasDataLoss )
{
*pHasDataLoss = (FALSE != dataloss);
}
return cchCvt;
}
// ! MPLAT_UNIX ----------------------------------------------------------------
#endif

156
source/shared/localizationimpl.cpp
View file

@ -227,16 +227,6 @@ public:
bool IConvCachePool::s_PoolDestroyed = false;
#ifdef DEBUG
// This is only used by unit tests.
// Product code should directly use IConvCachePool::Depth from
// within this translation unit.
USHORT GetIConvCachePoolDepth( UINT dstCP, UINT srcCP )
{
return IConvCachePool::Depth( dstCP, srcCP );
}
#endif // DEBUG
IConvCache::IConvCache( int dstIdx, int srcIdx )
: m_iconv( iconv_open(
cp_iconv::g_cp_iconv[dstIdx].IConvEncoding,
@ -315,63 +305,6 @@ const SystemLocale & SystemLocale::Singleton()
return s_Default;
}
int SystemLocale::GetResourcePath( char * buffer, size_t cchBuffer ) const
{
// XPLAT_ODBC_TODO: VSTS 718708 Localization
// Also need to use AdjustLCID logic when handling more locales
return snprintf( buffer, cchBuffer, "/opt/microsoft/msodbcsql/share/resources/en_US/");
}
DWORD SystemLocale::CurrentTimeZoneBias( LONG * offsetInMinutes, DWORD * tzinfo ) const
{
if ( NULL == offsetInMinutes )
return ERROR_INVALID_PARAMETER;
time_t now = time( NULL );
if ( (time_t)(-1) == now )
return ERROR_NOT_SUPPORTED;
struct tm utc, local;
if ( NULL == gmtime_r(&now, &utc) || NULL == localtime_r(&now, &local) )
return ERROR_INVALID_DATA;
*offsetInMinutes = BiasInMinutes( utc, local );
if ( NULL != tzinfo )
{
*tzinfo = (0 == local.tm_isdst ? TIME_ZONE_ID_STANDARD : (0 < local.tm_isdst ? TIME_ZONE_ID_DAYLIGHT : TIME_ZONE_ID_UNKNOWN));
}
return ERROR_SUCCESS;
}
DWORD SystemLocale::CurrentLocalTime( LPSYSTEMTIME pTime )
{
if ( NULL == pTime )
return ERROR_INVALID_PARAMETER;
memset( pTime, 0, sizeof(SYSTEMTIME) );
time_t now = time( NULL );
if ( (time_t)(-1) == now )
return ERROR_NOT_SUPPORTED;
struct tm local;
if ( NULL == localtime_r(&now, &local) )
return ERROR_INVALID_DATA;
pTime->wYear = local.tm_year + 1900;
pTime->wMonth = local.tm_mon + 1;
pTime->wDay = local.tm_mday;
pTime->wHour = local.tm_hour;
pTime->wMinute = local.tm_min;
pTime->wSecond = local.tm_sec;
pTime->wMilliseconds = 0;
pTime->wDayOfWeek = local.tm_wday;
return ERROR_SUCCESS;
}
size_t SystemLocale::ToUtf16( UINT srcCodePage, const char * src, SSIZE_T cchSrc, WCHAR * dest, size_t cchDest, DWORD * pErrorCode )
{
srcCodePage = ExpandSpecialCP( srcCodePage );
@ -432,95 +365,6 @@ size_t SystemLocale::FromUtf16Strict(UINT destCodePage, const WCHAR * src, SSIZE
return cvt.Convert(dest, cchDest, src, cchSrcActual, true, &hasLoss, pErrorCode);
}
size_t SystemLocale::ToLower( const char * src, SSIZE_T cchSrc, char * dest, size_t cchDest, DWORD * pErrorCode ) const
{
size_t cchSrcActual = (cchSrc < 0 ? (1+strlen(src)) : cchSrc);
if ( 0 == cchSrcActual )
{
if ( NULL != pErrorCode )
*pErrorCode = ERROR_INVALID_PARAMETER;
return 0;
}
if ( 0 == cchDest )
{
if ( NULL != pErrorCode )
*pErrorCode = ERROR_SUCCESS;
return cchSrcActual;
}
else if ( cchDest < cchSrcActual )
{
if ( NULL != pErrorCode )
*pErrorCode = ERROR_INSUFFICIENT_BUFFER;
return 0;
}
memcpy_s( dest, cchSrcActual, src, cchSrcActual );
use_facet< ctype< char > >(*m_pLocale).tolower( dest, dest+cchSrcActual );
if ( NULL != pErrorCode )
*pErrorCode = ERROR_SUCCESS;
return cchSrcActual;
}
int SystemLocale::Compare( const char * left, SSIZE_T cchLeft, const char * right, SSIZE_T cchRight, DWORD * pErrorCode ) const
{
if ( NULL == left || NULL == right || 0 == cchLeft || 0 == cchRight )
{
if ( NULL != pErrorCode )
*pErrorCode = ERROR_INVALID_PARAMETER;
return CSTR_ERROR;
}
size_t cchLeftActual = (cchLeft < 0 ? strlen(left) : cchLeft);
size_t cchRightActual = (cchRight < 0 ? strlen(right) : cchRight);
int cmp = strncmp( left, right, min(cchLeftActual, cchRightActual) );
if ( 0 == cmp )
{
if ( cchLeftActual < cchRightActual )
cmp = -1;
else if ( cchLeftActual > cchRightActual )
cmp = 1;
}
else if ( cmp < 0 )
cmp = 1; // CompareString is inverse of strcmp
else
cmp = -1; // CompareString is inverse of strcmp
if ( NULL != pErrorCode )
*pErrorCode = ERROR_SUCCESS;
return cmp+2;
}
int SystemLocale::CompareIgnoreCase( const char * left, SSIZE_T cchLeft, const char * right, SSIZE_T cchRight, DWORD * pErrorCode ) const
{
if ( NULL == left || NULL == right || 0 == cchLeft || 0 == cchRight )
{
if ( NULL != pErrorCode )
*pErrorCode = ERROR_INVALID_PARAMETER;
return CSTR_ERROR;
}
size_t cchLeftActual = (cchLeft < 0 ? strlen(left) : cchLeft);
size_t cchRightActual = (cchRight < 0 ? strlen(right) : cchRight);
int cmp = strncasecmp( left, right, min(cchLeftActual, cchRightActual) );
if ( 0 == cmp )
{
if ( cchLeftActual < cchRightActual )
cmp = -1;
else if ( cchLeftActual > cchRightActual )
cmp = 1;
}
else if ( cmp < 0 )
cmp = 1; // CompareString is inverse of strcmp
else
cmp = -1; // CompareString is inverse of strcmp
if ( NULL != pErrorCode )
*pErrorCode = ERROR_SUCCESS;
return cmp+2;
}
char * SystemLocale::NextChar( UINT codepage, const char * start, size_t cchBytesLeft )
{
if ( NULL == start || '\0' == *start || 0 == cchBytesLeft )

13
source/shared/typedefs_for_linux.h
View file

@ -44,16 +44,6 @@ DWORD FormatMessageA(
va_list *Arguments
);
DWORD FormatMessageW(
DWORD dwFlags,
LPCVOID lpSource,
DWORD dwMessageId,
DWORD dwLanguageId,
LPWSTR lpBuffer,
DWORD nSize,
va_list *Arguments
);
#ifndef _WIN32
#define FormatMessage FormatMessageA
#else
@ -73,12 +63,9 @@ DWORD FormatMessageW(
#define ERROR_INVALID_DATA 13L
typedef int errno_t;
int mplat_snwprintf_s(WCHAR *str, size_t sizeOfBuffer, size_t count, const WCHAR *format, ...);
int mplat_vsnwprintf( WCHAR * buffer, size_t count, const WCHAR * format, va_list args );
int mplat_snprintf_s(char *str, size_t sizeOfBuffer, size_t count, const char *format, ...);
int mplat_vsnprintf( char * buffer, size_t count, const char * format, va_list args );
errno_t mplat_wctomb_s(int *pRetValue, char *mbchar, size_t sizeInBytes, WCHAR wchar);
WCHAR * mplat_wcscpy(WCHAR * _Dst, const WCHAR * _Src);
char * mplat_cscpy(char * _Dst, const char * _Src);
BOOL IsDBCSLeadByteEx(__inn UINT CodePage, __inn BYTE TestChar);

18
source/shared/xplat.h
View file

@ -265,8 +265,6 @@ typedef void* SQLHWND;
// End definitions for UnixODBC SQL headers
// ----------------------------------------------------------------------------
#define UNREFERENCED_PARAMETER(arg)
// From share.h
#define _SH_DENYNO 0x40 /* deny none mode */
@ -283,9 +281,6 @@ typedef void* SQLHWND;
#define VER_MAJORVERSION 0x0000002
#define VER_SERVICEPACKMINOR 0x0000010
#define VER_SERVICEPACKMAJOR 0x0000020
#define VER_SET_CONDITION(_m_,_t_,_c_) \
((_m_)=VerSetConditionMask((_m_),(_t_),(_c_)))
// Predeclared types from windef needed for remaining WinNT types
// to break circular dependency between WinNT.h and windef.h types.
@ -408,11 +403,6 @@ typedef INT_PTR (*NEARPROC)();
typedef INT_PTR (*PROC)();
DWORD GetFileSize(
__inn HANDLE hFile,
__out_opt LPDWORD lpFileSizeHigh
);
typedef union _ULARGE_INTEGER {
struct {
DWORD LowPart;
@ -440,14 +430,6 @@ typedef ULARGE_INTEGER *PULARGE_INTEGER;
#endif
ULONGLONG
VerSetConditionMask(
IN ULONGLONG ConditionMask,
IN DWORD TypeMask,
IN BYTE Condition
);
//// ntdef.h
#define __unaligned
#ifndef UNALIGNED

7542
source/shared/xplat_intsafe.h
View file

@ -88,7548 +88,6 @@ 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

35
source/shared/xplat_winnls.h
View file

@ -106,39 +106,4 @@ IsDBCSLeadByte(
__inn BYTE TestChar);
#ifdef MPLAT_UNIX
// XPLAT_ODBC_TODO: VSTS 718708 Localization
// Find way to remove this
LCID GetUserDefaultLCID();
#endif
BOOL IsValidCodePage(UINT CodePage);
#define HIGH_SURROGATE_START 0xd800
#define HIGH_SURROGATE_END 0xdbff
#define LOW_SURROGATE_START 0xdc00
#define LOW_SURROGATE_END 0xdfff
#define IS_HIGH_SURROGATE(wch) (((wch) >= HIGH_SURROGATE_START) && ((wch) <= HIGH_SURROGATE_END))
#define IS_LOW_SURROGATE(wch) (((wch) >= LOW_SURROGATE_START) && ((wch) <= LOW_SURROGATE_END))
int
GetLocaleInfoA(
__inn LCID Locale,
__inn LCTYPE LCType,
__out_ecount_opt(cchData) LPSTR lpLCData,
__inn int cchData);
int
GetLocaleInfoW(
__inn LCID Locale,
__inn LCTYPE LCType,
__out_ecount_opt(cchData) LPWSTR lpLCData,
__inn int cchData);
#ifdef UNICODE
#define GetLocaleInfo GetLocaleInfoW
#else
#define GetLocaleInfo GetLocaleInfoA
#endif // !UNICODE
#endif // XPLAT_WINNLS_H