From a297fe0c54995fd3c93757a2a24847a91a4ff757 Mon Sep 17 00:00:00 2001 From: David Puglielli Date: Mon, 15 May 2017 16:22:58 -0700 Subject: [PATCH] Removed unused xplat functions --- source/shared/FormattedPrint.cpp | 1191 ---- source/shared/FormattedPrint.h | 7 - source/shared/interlockedatomic.h | 20 - source/shared/interlockedatomic_gcc.h | 30 - source/shared/localization.hpp | 526 +- source/shared/localizationimpl.cpp | 156 - source/shared/typedefs_for_linux.h | 13 - source/shared/xplat.h | 18 - source/shared/xplat_intsafe.h | 7542 ------------------------- source/shared/xplat_winnls.h | 35 - 10 files changed, 9 insertions(+), 9529 deletions(-) diff --git a/source/shared/FormattedPrint.cpp b/source/shared/FormattedPrint.cpp index b3aa3e7a..66f7240b 100644 --- a/source/shared/FormattedPrint.cpp +++ b/source/shared/FormattedPrint.cpp @@ -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 * output, const char *format, v return charsout; /* return value = number of characters written */ } -// Tools\vc\src\crt\amd64\output.c -int FormattedPrintW( IFormattedPrintOutput * 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 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(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(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(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 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 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; diff --git a/source/shared/FormattedPrint.h b/source/shared/FormattedPrint.h index f143a2a4..7e7fa3b4 100644 --- a/source/shared/FormattedPrint.h +++ b/source/shared/FormattedPrint.h @@ -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 * output, const char *format, va_list argptr ); -int FormattedPrintW( IFormattedPrintOutput * output, const WCHAR *format, va_list argptr ); template< typename T > class BufferOutput : public FormattedOutput diff --git a/source/shared/interlockedatomic.h b/source/shared/interlockedatomic.h index 71ee5196..839264cf 100644 --- a/source/shared/interlockedatomic.h +++ b/source/shared/interlockedatomic.h @@ -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 // diff --git a/source/shared/interlockedatomic_gcc.h b/source/shared/interlockedatomic_gcc.h index 6ab246e6..2873ec1e 100644 --- a/source/shared/interlockedatomic_gcc.h +++ b/source/shared/interlockedatomic_gcc.h @@ -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__ diff --git a/source/shared/localization.hpp b/source/shared/localization.hpp index 18e30b27..1bcc4936 100644 --- a/source/shared/localization.hpp +++ b/source/shared/localization.hpp @@ -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::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(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 diff --git a/source/shared/localizationimpl.cpp b/source/shared/localizationimpl.cpp index bff42721..6b596134 100644 --- a/source/shared/localizationimpl.cpp +++ b/source/shared/localizationimpl.cpp @@ -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 ) diff --git a/source/shared/typedefs_for_linux.h b/source/shared/typedefs_for_linux.h index 15113d85..91fbabce 100644 --- a/source/shared/typedefs_for_linux.h +++ b/source/shared/typedefs_for_linux.h @@ -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); diff --git a/source/shared/xplat.h b/source/shared/xplat.h index 7bc12faa..09a08383 100644 --- a/source/shared/xplat.h +++ b/source/shared/xplat.h @@ -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 diff --git a/source/shared/xplat_intsafe.h b/source/shared/xplat_intsafe.h index e0cdd76b..9fdd0781 100644 --- a/source/shared/xplat_intsafe.h +++ b/source/shared/xplat_intsafe.h @@ -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 diff --git a/source/shared/xplat_winnls.h b/source/shared/xplat_winnls.h index 0f21a44a..91fd620f 100644 --- a/source/shared/xplat_winnls.h +++ b/source/shared/xplat_winnls.h @@ -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