sdk/include/psdk/strsafe.h

   1 /**
   2  * This file has no copyright assigned and is placed in the Public Domain.
   3  * This file is part of the w64 mingw-runtime package.
   4  * No warranty is given; refer to the file DISCLAIMER.PD within this package.
   5  */
   6 #ifndef _STRSAFE_H_INCLUDED_
   7 #define _STRSAFE_H_INCLUDED_
   8
   9 #include <_mingw_unicode.h>
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <stdarg.h>
  13 #include <specstrings.h>
  14
  15 #ifdef __clang__
  16 #pragma clang diagnostic push
  17 #pragma clang diagnostic ignored "-Wignored-attributes"
  18 #endif
  19
  20 #ifndef _SIZE_T_DEFINED
  21 #define _SIZE_T_DEFINED
  22 #undef size_t
  23 #ifdef _WIN64
  24 __MINGW_EXTENSION typedef unsigned __int64 size_t;
  25 #else
  26 typedef unsigned int size_t;
  27 #endif
  28 #endif
  29
  30 #ifndef _SSIZE_T_DEFINED
  31 #define _SSIZE_T_DEFINED
  32 #undef ssize_t
  33 #ifdef _WIN64
  34 __MINGW_EXTENSION typedef __int64 ssize_t;
  35 #else
  36 typedef int ssize_t;
  37 #endif
  38 #endif
  39
  40 #ifndef _WCHAR_T_DEFINED
  41 #define _WCHAR_T_DEFINED
  42 typedef unsigned short wchar_t;
  43 #endif
  44
  45 #ifndef _HRESULT_DEFINED
  46 #define _HRESULT_DEFINED
  47 typedef long HRESULT;
  48 #endif
  49
  50 #ifndef SUCCEEDED
  51 #define SUCCEEDED(hr) ((HRESULT)(hr) >= 0)
  52 #endif
  53
  54 #ifndef FAILED
  55 #define FAILED(hr) ((HRESULT)(hr) < 0)
  56 #endif
  57
  58 #ifndef S_OK
  59 #define S_OK ((HRESULT)0x00000000L)
  60 #endif
  61
  62 #ifndef C_ASSERT
  63 #ifdef _MSC_VER
  64 # define C_ASSERT(e) typedef char __C_ASSERT__[(e)?1:-1]
  65 #else
  66 # define C_ASSERT(e) extern void __C_ASSERT__(int [(e)?1:-1])
  67 #endif
  68 #endif /* C_ASSERT */
  69
  70 #ifdef __cplusplus
  71 #define _STRSAFE_EXTERN_C extern "C"
  72 #else
  73 #define _STRSAFE_EXTERN_C extern
  74 #endif
  75
  76 #ifndef WINAPI
  77 #define WINAPI __stdcall
  78 #endif
  79
  80 #define STRSAFEAPI static __inline HRESULT WINAPI
  81 #define STRSAFE_INLINE_API __CRT_INLINE HRESULT WINAPI
  82
  83 #define STRSAFE_MAX_CCH 2147483647
  84
  85 #ifndef _NTSTRSAFE_H_INCLUDED_
  86 #define STRSAFE_IGNORE_NULLS 0x00000100
  87 #define STRSAFE_FILL_BEHIND_NULL 0x00000200
  88 #define STRSAFE_FILL_ON_FAILURE 0x00000400
  89 #define STRSAFE_NULL_ON_FAILURE 0x00000800
  90 #define STRSAFE_NO_TRUNCATION 0x00001000
  91 #define STRSAFE_IGNORE_NULL_UNICODE_STRINGS 0x00010000
  92 #define STRSAFE_UNICODE_STRING_DEST_NULL_TERMINATED 0x00020000
  93
  94 #define STRSAFE_VALID_FLAGS (0x000000FF | STRSAFE_IGNORE_NULLS | STRSAFE_FILL_BEHIND_NULL | STRSAFE_FILL_ON_FAILURE | STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION)
  95 #define STRSAFE_UNICODE_STRING_VALID_FLAGS (STRSAFE_VALID_FLAGS | STRSAFE_IGNORE_NULL_UNICODE_STRINGS | STRSAFE_UNICODE_STRING_DEST_NULL_TERMINATED)
  96
  97 #define STRSAFE_FILL_BYTE(x) ((STRSAFE_DWORD)(((x) & 0x000000FF) | STRSAFE_FILL_BEHIND_NULL))
  98 #define STRSAFE_FAILURE_BYTE(x) ((STRSAFE_DWORD)(((x) & 0x000000FF) | STRSAFE_FILL_ON_FAILURE))
  99
 100 #define STRSAFE_GET_FILL_PATTERN(dwFlags) ((int)((dwFlags) & 0x000000FF))
 101 #endif
 102
 103 #define STRSAFE_E_INSUFFICIENT_BUFFER ((HRESULT)0x8007007AL)
 104 #define STRSAFE_E_INVALID_PARAMETER ((HRESULT)0x80070057L)
 105 #define STRSAFE_E_END_OF_FILE ((HRESULT)0x80070026L)
 106
 107 typedef char *STRSAFE_LPSTR;
 108 typedef const char *STRSAFE_LPCSTR;
 109 typedef wchar_t *STRSAFE_LPWSTR;
 110 typedef const wchar_t *STRSAFE_LPCWSTR;
 111
 112 typedef ULONG STRSAFE_DWORD;
 113
 114 STRSAFEAPI StringCopyWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc);
 115 STRSAFEAPI StringCopyWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc);
 116 STRSAFEAPI StringCopyExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 117 STRSAFEAPI StringCopyExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 118 STRSAFEAPI StringCopyNWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToCopy);
 119 STRSAFEAPI StringCopyNWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy);
 120 STRSAFEAPI StringCopyNExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cchToCopy,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 121 STRSAFEAPI StringCopyNExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 122 STRSAFEAPI StringCatWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc);
 123 STRSAFEAPI StringCatWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc);
 124 STRSAFEAPI StringCatExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 125 STRSAFEAPI StringCatExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 126 STRSAFEAPI StringCatNWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend);
 127 STRSAFEAPI StringCatNWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend);
 128 STRSAFEAPI StringCatNExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 129 STRSAFEAPI StringCatNExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 130 STRSAFEAPI StringVPrintfWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszFormat,va_list argList);
 131 STRSAFEAPI StringVPrintfWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszFormat,va_list argList);
 132 STRSAFEAPI StringVPrintfExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,va_list argList);
 133 STRSAFEAPI StringVPrintfExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,va_list argList);
 134 STRSAFEAPI StringLengthWorkerA(STRSAFE_LPCSTR psz,size_t cchMax,size_t *pcchLength);
 135 STRSAFEAPI StringLengthWorkerW(STRSAFE_LPCWSTR psz,size_t cchMax,size_t *pcchLength);
 136 STRSAFE_INLINE_API StringGetsExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 137 STRSAFE_INLINE_API StringGetsExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 138
 139 #define StringCchCopy __MINGW_NAME_AW(StringCchCopy)
 140
 141 STRSAFEAPI StringCchCopyA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc);
 142 STRSAFEAPI StringCchCopyW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc);
 143
 144 #ifndef __CRT__NO_INLINE
 145 STRSAFEAPI StringCchCopyA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc) {
 146   return (cchDest > STRSAFE_MAX_CCH ? STRSAFE_E_INVALID_PARAMETER : StringCopyWorkerA(pszDest,cchDest,pszSrc));
 147 }
 148
 149 STRSAFEAPI StringCchCopyW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc) {
 150   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 151   return StringCopyWorkerW(pszDest,cchDest,pszSrc);
 152 }
 153 #endif /* !__CRT__NO_INLINE */
 154
 155 #define StringCbCopy __MINGW_NAME_AW(StringCbCopy)
 156
 157 STRSAFEAPI StringCbCopyA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc);
 158 STRSAFEAPI StringCbCopyW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc);
 159
 160 #ifndef __CRT__NO_INLINE
 161 STRSAFEAPI StringCbCopyA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc) {
 162   if(cbDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 163   return StringCopyWorkerA(pszDest,cbDest,pszSrc);
 164 }
 165
 166 STRSAFEAPI StringCbCopyW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc) {
 167   size_t cchDest = cbDest / sizeof(wchar_t);
 168   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 169   return StringCopyWorkerW(pszDest,cchDest,pszSrc);
 170 }
 171 #endif /* !__CRT__NO_INLINE */
 172
 173 #define StringCchCopyEx __MINGW_NAME_AW(StringCchCopyEx)
 174
 175 STRSAFEAPI StringCchCopyExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 176 STRSAFEAPI StringCchCopyExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 177
 178 #ifndef __CRT__NO_INLINE
 179 STRSAFEAPI StringCchCopyExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags) {
 180   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 181   return StringCopyExWorkerA(pszDest,cchDest,cchDest,pszSrc,ppszDestEnd,pcchRemaining,dwFlags);
 182 }
 183
 184 STRSAFEAPI StringCchCopyExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags) {
 185   size_t cbDest;
 186   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 187   cbDest = cchDest * sizeof(wchar_t);
 188   return StringCopyExWorkerW(pszDest,cchDest,cbDest,pszSrc,ppszDestEnd,pcchRemaining,dwFlags);
 189 }
 190 #endif /* !__CRT__NO_INLINE */
 191
 192 #define StringCbCopyEx __MINGW_NAME_AW(StringCbCopyEx)
 193
 194 STRSAFEAPI StringCbCopyExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
 195 STRSAFEAPI StringCbCopyExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
 196
 197 #ifndef __CRT__NO_INLINE
 198 STRSAFEAPI StringCbCopyExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags) {
 199   HRESULT hr;
 200   size_t cchRemaining = 0;
 201   if(cbDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 202   hr = StringCopyExWorkerA(pszDest,cbDest,cbDest,pszSrc,ppszDestEnd,&cchRemaining,dwFlags);
 203   if(SUCCEEDED(hr) || hr == STRSAFE_E_INSUFFICIENT_BUFFER) {
 204     if(pcbRemaining)
 205       *pcbRemaining = (cchRemaining*sizeof(char)) + (cbDest % sizeof(char));
 206   }
 207   return hr;
 208 }
 209
 210 STRSAFEAPI StringCbCopyExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags) {
 211   HRESULT hr;
 212   size_t cchDest = cbDest / sizeof(wchar_t);
 213   size_t cchRemaining = 0;
 214
 215   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 216   hr = StringCopyExWorkerW(pszDest,cchDest,cbDest,pszSrc,ppszDestEnd,&cchRemaining,dwFlags);
 217   if(SUCCEEDED(hr) || (hr==STRSAFE_E_INSUFFICIENT_BUFFER)) {
 218     if(pcbRemaining)
 219       *pcbRemaining = (cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t));
 220   }
 221   return hr;
 222 }
 223 #endif /* !__CRT__NO_INLINE */
 224
 225 STRSAFEAPI StringCchCopyNA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToCopy);
 226 STRSAFEAPI StringCchCopyNW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy);
 227 #define StringCchCopyN __MINGW_NAME_AW(StringCchCopyN)
 228
 229 #ifndef __CRT__NO_INLINE
 230 STRSAFEAPI StringCchCopyNA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToCopy) {
 231   if(cchDest > STRSAFE_MAX_CCH || cchToCopy > STRSAFE_MAX_CCH)
 232     return STRSAFE_E_INVALID_PARAMETER;
 233   return StringCopyNWorkerA(pszDest,cchDest,pszSrc,cchToCopy);
 234 }
 235
 236 STRSAFEAPI StringCchCopyNW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy) {
 237   if(cchDest > STRSAFE_MAX_CCH || cchToCopy > STRSAFE_MAX_CCH)
 238     return STRSAFE_E_INVALID_PARAMETER;
 239   return StringCopyNWorkerW(pszDest,cchDest,pszSrc,cchToCopy);
 240 }
 241 #endif /* !__CRT__NO_INLINE */
 242
 243 STRSAFEAPI StringCbCopyNA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToCopy);
 244 STRSAFEAPI StringCbCopyNW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToCopy);
 245
 246 #define StringCbCopyN __MINGW_NAME_AW(StringCbCopyN)
 247
 248 #ifndef __CRT__NO_INLINE
 249 STRSAFEAPI StringCbCopyNA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToCopy) {
 250   if(cbDest > STRSAFE_MAX_CCH || cbToCopy > STRSAFE_MAX_CCH)
 251     return STRSAFE_E_INVALID_PARAMETER;
 252   return StringCopyNWorkerA(pszDest,cbDest,pszSrc,cbToCopy);
 253 }
 254
 255 STRSAFEAPI StringCbCopyNW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToCopy) {
 256   size_t cchDest  = cbDest / sizeof(wchar_t);
 257   size_t cchToCopy = cbToCopy / sizeof(wchar_t);
 258   if(cchDest > STRSAFE_MAX_CCH || cchToCopy > STRSAFE_MAX_CCH)
 259     return STRSAFE_E_INVALID_PARAMETER;
 260   return StringCopyNWorkerW(pszDest,cchDest,pszSrc,cchToCopy);
 261 }
 262 #endif /* !__CRT__NO_INLINE */
 263
 264 STRSAFEAPI StringCchCopyNExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToCopy,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 265 STRSAFEAPI StringCchCopyNExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 266
 267 #define StringCchCopyNEx __MINGW_NAME_AW(StringCchCopyNEx)
 268
 269 #ifndef __CRT__NO_INLINE
 270 STRSAFEAPI StringCchCopyNExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToCopy,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags) {
 271   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 272   return StringCopyNExWorkerA(pszDest,cchDest,cchDest,pszSrc,cchToCopy,ppszDestEnd,pcchRemaining,dwFlags);
 273 }
 274
 275 STRSAFEAPI StringCchCopyNExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags) {
 276   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 277   return StringCopyNExWorkerW(pszDest,cchDest,cchDest * sizeof(wchar_t),pszSrc,cchToCopy,ppszDestEnd,pcchRemaining,dwFlags);
 278 }
 279 #endif /* !__CRT__NO_INLINE */
 280
 281 STRSAFEAPI StringCbCopyNExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToCopy,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
 282 STRSAFEAPI StringCbCopyNExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToCopy,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
 283
 284 #define StringCbCopyNEx __MINGW_NAME_AW(StringCbCopyNEx)
 285
 286 #ifndef __CRT__NO_INLINE
 287 STRSAFEAPI StringCbCopyNExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToCopy,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags) {
 288   HRESULT hr;
 289   size_t cchRemaining = 0;
 290   if(cbDest > STRSAFE_MAX_CCH)
 291     hr = STRSAFE_E_INVALID_PARAMETER;
 292   else
 293     hr = StringCopyNExWorkerA(pszDest,cbDest,cbDest,pszSrc,cbToCopy,ppszDestEnd,&cchRemaining,dwFlags);
 294   if((SUCCEEDED(hr) || hr == STRSAFE_E_INSUFFICIENT_BUFFER) && pcbRemaining)
 295     *pcbRemaining = cchRemaining;
 296   return hr;
 297 }
 298
 299 STRSAFEAPI StringCbCopyNExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToCopy,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags) {
 300   HRESULT hr;
 301   size_t cchDest;
 302   size_t cchToCopy;
 303   size_t cchRemaining = 0;
 304   cchDest = cbDest / sizeof(wchar_t);
 305   cchToCopy = cbToCopy / sizeof(wchar_t);
 306   if(cchDest > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
 307   else hr = StringCopyNExWorkerW(pszDest,cchDest,cbDest,pszSrc,cchToCopy,ppszDestEnd,&cchRemaining,dwFlags);
 308   if((SUCCEEDED(hr) || hr == STRSAFE_E_INSUFFICIENT_BUFFER) && pcbRemaining)
 309     *pcbRemaining = (cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t));
 310   return hr;
 311 }
 312 #endif /* !__CRT__NO_INLINE */
 313
 314 STRSAFEAPI StringCchCatA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc);
 315 STRSAFEAPI StringCchCatW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc);
 316
 317 #define StringCchCat __MINGW_NAME_AW(StringCchCat)
 318
 319 #ifndef __CRT__NO_INLINE
 320 STRSAFEAPI StringCchCatA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc) {
 321   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 322   return StringCatWorkerA(pszDest,cchDest,pszSrc);
 323 }
 324
 325 STRSAFEAPI StringCchCatW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc) {
 326   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 327   return StringCatWorkerW(pszDest,cchDest,pszSrc);
 328 }
 329 #endif /* !__CRT__NO_INLINE */
 330
 331 STRSAFEAPI StringCbCatA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc);
 332 STRSAFEAPI StringCbCatW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc);
 333
 334 #define StringCbCat __MINGW_NAME_AW(StringCbCat)
 335
 336 #ifndef __CRT__NO_INLINE
 337 STRSAFEAPI StringCbCatA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc) {
 338   if(cbDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 339   return StringCatWorkerA(pszDest,cbDest,pszSrc);
 340 }
 341
 342 STRSAFEAPI StringCbCatW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc) {
 343   size_t cchDest = cbDest / sizeof(wchar_t);
 344   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 345   return StringCatWorkerW(pszDest,cchDest,pszSrc);
 346 }
 347 #endif /* !__CRT__NO_INLINE */
 348
 349 STRSAFEAPI StringCchCatExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 350 STRSAFEAPI StringCchCatExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 351
 352 #define StringCchCatEx __MINGW_NAME_AW(StringCchCatEx)
 353
 354 #ifndef __CRT__NO_INLINE
 355 STRSAFEAPI StringCchCatExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags) {
 356   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 357   return StringCatExWorkerA(pszDest,cchDest,cchDest,pszSrc,ppszDestEnd,pcchRemaining,dwFlags);
 358 }
 359
 360 STRSAFEAPI StringCchCatExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags) {
 361   size_t cbDest = cchDest*sizeof(wchar_t);
 362   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 363   return StringCatExWorkerW(pszDest,cchDest,cbDest,pszSrc,ppszDestEnd,pcchRemaining,dwFlags);
 364 }
 365 #endif /* !__CRT__NO_INLINE */
 366
 367 STRSAFEAPI StringCbCatExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
 368 STRSAFEAPI StringCbCatExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
 369
 370 #define StringCbCatEx __MINGW_NAME_AW(StringCbCatEx)
 371
 372 #ifndef __CRT__NO_INLINE
 373 STRSAFEAPI StringCbCatExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags) {
 374   HRESULT hr;
 375   size_t cchRemaining = 0;
 376   if(cbDest > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
 377   else hr = StringCatExWorkerA(pszDest,cbDest,cbDest,pszSrc,ppszDestEnd,&cchRemaining,dwFlags);
 378   if((SUCCEEDED(hr) || hr == STRSAFE_E_INSUFFICIENT_BUFFER) && pcbRemaining)
 379     *pcbRemaining = (cchRemaining*sizeof(char)) + (cbDest % sizeof(char));
 380   return hr;
 381 }
 382
 383 STRSAFEAPI StringCbCatExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags) {
 384   HRESULT hr;
 385   size_t cchDest = cbDest / sizeof(wchar_t);
 386   size_t cchRemaining = 0;
 387
 388   if(cchDest > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
 389   else hr = StringCatExWorkerW(pszDest,cchDest,cbDest,pszSrc,ppszDestEnd,&cchRemaining,dwFlags);
 390   if((SUCCEEDED(hr) || hr == STRSAFE_E_INSUFFICIENT_BUFFER) && pcbRemaining)
 391     *pcbRemaining = (cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t));
 392   return hr;
 393 }
 394 #endif /* !__CRT__NO_INLINE */
 395
 396 STRSAFEAPI StringCchCatNA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend);
 397 STRSAFEAPI StringCchCatNW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend);
 398
 399 #define StringCchCatN __MINGW_NAME_AW(StringCchCatN)
 400
 401 #ifndef __CRT__NO_INLINE
 402 STRSAFEAPI StringCchCatNA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend) {
 403   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 404   return StringCatNWorkerA(pszDest,cchDest,pszSrc,cchToAppend);
 405 }
 406
 407 STRSAFEAPI StringCchCatNW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend) {
 408   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 409   return StringCatNWorkerW(pszDest,cchDest,pszSrc,cchToAppend);
 410 }
 411 #endif /* !__CRT__NO_INLINE */
 412
 413 STRSAFEAPI StringCbCatNA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToAppend);
 414 STRSAFEAPI StringCbCatNW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToAppend);
 415
 416 #define StringCbCatN __MINGW_NAME_AW(StringCbCatN)
 417
 418 #ifndef __CRT__NO_INLINE
 419 STRSAFEAPI StringCbCatNA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToAppend) {
 420   if(cbDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 421   return StringCatNWorkerA(pszDest,cbDest,pszSrc,cbToAppend);
 422 }
 423
 424 STRSAFEAPI StringCbCatNW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToAppend) {
 425   size_t cchDest = cbDest / sizeof(wchar_t);
 426   size_t cchToAppend = cbToAppend / sizeof(wchar_t);
 427
 428   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 429   return StringCatNWorkerW(pszDest,cchDest,pszSrc,cchToAppend);
 430 }
 431 #endif /* !__CRT__NO_INLINE */
 432
 433 STRSAFEAPI StringCchCatNExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 434 STRSAFEAPI StringCchCatNExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 435
 436 #define StringCchCatNEx __MINGW_NAME_AW(StringCchCatNEx)
 437
 438 #ifndef __CRT__NO_INLINE
 439 STRSAFEAPI StringCchCatNExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags) {
 440   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 441   return StringCatNExWorkerA(pszDest,cchDest,cchDest,pszSrc,cchToAppend,ppszDestEnd,pcchRemaining,dwFlags);
 442 }
 443
 444 STRSAFEAPI StringCchCatNExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags) {
 445   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 446   return StringCatNExWorkerW(pszDest,cchDest,(cchDest*sizeof(wchar_t)),pszSrc,cchToAppend,ppszDestEnd,pcchRemaining,dwFlags);
 447 }
 448 #endif
 449
 450 STRSAFEAPI StringCbCatNExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToAppend,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
 451 STRSAFEAPI StringCbCatNExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToAppend,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
 452
 453 #define StringCbCatNEx __MINGW_NAME_AW(StringCbCatNEx)
 454
 455 #ifndef __CRT__NO_INLINE
 456 STRSAFEAPI StringCbCatNExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToAppend,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags) {
 457   HRESULT hr;
 458   size_t cchRemaining = 0;
 459   if(cbDest > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
 460   else hr = StringCatNExWorkerA(pszDest,cbDest,cbDest,pszSrc,cbToAppend,ppszDestEnd,&cchRemaining,dwFlags);
 461   if((SUCCEEDED(hr) || hr == STRSAFE_E_INSUFFICIENT_BUFFER) && pcbRemaining)
 462     *pcbRemaining = (cchRemaining*sizeof(char)) + (cbDest % sizeof(char));
 463   return hr;
 464 }
 465
 466 STRSAFEAPI StringCbCatNExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToAppend,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags) {
 467   HRESULT hr;
 468   size_t cchDest = cbDest / sizeof(wchar_t);
 469   size_t cchToAppend = cbToAppend / sizeof(wchar_t);
 470   size_t cchRemaining = 0;
 471   if(cchDest > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
 472   else hr = StringCatNExWorkerW(pszDest,cchDest,cbDest,pszSrc,cchToAppend,ppszDestEnd,&cchRemaining,dwFlags);
 473   if((SUCCEEDED(hr) || hr == STRSAFE_E_INSUFFICIENT_BUFFER) && pcbRemaining)
 474     *pcbRemaining = (cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t));
 475   return hr;
 476 }
 477 #endif /* !__CRT__NO_INLINE */
 478
 479 STRSAFEAPI StringCchVPrintfA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszFormat,va_list argList);
 480 STRSAFEAPI StringCchVPrintfW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszFormat,va_list argList);
 481
 482 #define StringCchVPrintf __MINGW_NAME_AW(StringCchVPrintf)
 483
 484 #ifndef __CRT__NO_INLINE
 485 STRSAFEAPI StringCchVPrintfA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszFormat,va_list argList) {
 486   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 487   return StringVPrintfWorkerA(pszDest,cchDest,pszFormat,argList);
 488 }
 489
 490 STRSAFEAPI StringCchVPrintfW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszFormat,va_list argList) {
 491   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 492   return StringVPrintfWorkerW(pszDest,cchDest,pszFormat,argList);
 493 }
 494 #endif /* !__CRT__NO_INLINE */
 495
 496 STRSAFEAPI StringCbVPrintfA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszFormat,va_list argList);
 497 STRSAFEAPI StringCbVPrintfW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszFormat,va_list argList);
 498
 499 #define StringCbVPrintf __MINGW_NAME_AW(StringCbVPrintf)
 500
 501 #ifndef __CRT__NO_INLINE
 502 STRSAFEAPI StringCbVPrintfA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszFormat,va_list argList) {
 503   if(cbDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 504   return StringVPrintfWorkerA(pszDest,cbDest,pszFormat,argList);
 505 }
 506
 507 STRSAFEAPI StringCbVPrintfW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszFormat,va_list argList) {
 508   size_t cchDest = cbDest / sizeof(wchar_t);
 509   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 510   return StringVPrintfWorkerW(pszDest,cchDest,pszFormat,argList);
 511 }
 512 #endif /* !__CRT__NO_INLINE */
 513
 514 STRSAFEAPI StringCchPrintfA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszFormat,...);
 515 STRSAFEAPI StringCchPrintfW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszFormat,...);
 516
 517 #define StringCchPrintf __MINGW_NAME_AW(StringCchPrintf)
 518
 519 #ifndef __CRT__NO_INLINE
 520 STRSAFEAPI StringCchPrintfA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszFormat,...) {
 521   HRESULT hr;
 522   va_list argList;
 523   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 524   va_start(argList,pszFormat);
 525   hr = StringVPrintfWorkerA(pszDest,cchDest,pszFormat,argList);
 526   va_end(argList);
 527   return hr;
 528 }
 529
 530 STRSAFEAPI StringCchPrintfW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszFormat,...) {
 531   HRESULT hr;
 532   va_list argList;
 533   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 534   va_start(argList,pszFormat);
 535   hr = StringVPrintfWorkerW(pszDest,cchDest,pszFormat,argList);
 536   va_end(argList);
 537   return hr;
 538 }
 539 #endif /* !__CRT__NO_INLINE */
 540
 541 STRSAFEAPI StringCbPrintfA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszFormat,...);
 542 STRSAFEAPI StringCbPrintfW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszFormat,...);
 543
 544 #define StringCbPrintf __MINGW_NAME_AW(StringCbPrintf)
 545
 546 #ifndef __CRT__NO_INLINE
 547 STRSAFEAPI StringCbPrintfA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszFormat,...) {
 548   HRESULT hr;
 549   va_list argList;
 550   if(cbDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 551   va_start(argList,pszFormat);
 552   hr = StringVPrintfWorkerA(pszDest,cbDest,pszFormat,argList);
 553   va_end(argList);
 554   return hr;
 555 }
 556
 557 STRSAFEAPI StringCbPrintfW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszFormat,...) {
 558   HRESULT hr;
 559   va_list argList;
 560   size_t cchDest = cbDest / sizeof(wchar_t);
 561   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 562   va_start(argList,pszFormat);
 563   hr = StringVPrintfWorkerW(pszDest,cchDest,pszFormat,argList);
 564   va_end(argList);
 565   return hr;
 566 }
 567 #endif /* !__CRT__NO_INLINE */
 568
 569 STRSAFEAPI StringCchPrintfExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,...);
 570 STRSAFEAPI StringCchPrintfExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,...);
 571
 572 #define StringCchPrintfEx __MINGW_NAME_AW(StringCchPrintfEx)
 573
 574 #ifndef __CRT__NO_INLINE
 575 STRSAFEAPI StringCchPrintfExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,...) {
 576   HRESULT hr;
 577   va_list argList;
 578   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 579   va_start(argList,pszFormat);
 580   hr = StringVPrintfExWorkerA(pszDest,cchDest,cchDest,ppszDestEnd,pcchRemaining,dwFlags,pszFormat,argList);
 581   va_end(argList);
 582   return hr;
 583 }
 584
 585 STRSAFEAPI StringCchPrintfExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,...) {
 586   HRESULT hr;
 587   size_t cbDest = cchDest * sizeof(wchar_t);
 588   va_list argList;
 589   if(cchDest > STRSAFE_MAX_CCH) return STRSAFE_E_INVALID_PARAMETER;
 590   va_start(argList,pszFormat);
 591   hr = StringVPrintfExWorkerW(pszDest,cchDest,cbDest,ppszDestEnd,pcchRemaining,dwFlags,pszFormat,argList);
 592   va_end(argList);
 593   return hr;
 594 }
 595 #endif /* !__CRT__NO_INLINE */
 596
 597 STRSAFEAPI StringCbPrintfExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,...);
 598 STRSAFEAPI StringCbPrintfExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,...);
 599
 600 #define StringCbPrintfEx __MINGW_NAME_AW(StringCbPrintfEx)
 601
 602 #ifndef __CRT__NO_INLINE
 603 STRSAFEAPI StringCbPrintfExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,...) {
 604   HRESULT hr;
 605   size_t cchDest;
 606   size_t cchRemaining = 0;
 607   cchDest = cbDest / sizeof(char);
 608   if(cchDest > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
 609   else {
 610     va_list argList;
 611     va_start(argList,pszFormat);
 612     hr = StringVPrintfExWorkerA(pszDest,cchDest,cbDest,ppszDestEnd,&cchRemaining,dwFlags,pszFormat,argList);
 613     va_end(argList);
 614   }
 615   if(SUCCEEDED(hr) || (hr==STRSAFE_E_INSUFFICIENT_BUFFER)) {
 616     if(pcbRemaining) {
 617       *pcbRemaining = (cchRemaining*sizeof(char)) + (cbDest % sizeof(char));
 618     }
 619   }
 620   return hr;
 621 }
 622
 623 STRSAFEAPI StringCbPrintfExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,...) {
 624   HRESULT hr;
 625   size_t cchDest;
 626   size_t cchRemaining = 0;
 627   cchDest = cbDest / sizeof(wchar_t);
 628   if(cchDest > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
 629   else {
 630     va_list argList;
 631     va_start(argList,pszFormat);
 632     hr = StringVPrintfExWorkerW(pszDest,cchDest,cbDest,ppszDestEnd,&cchRemaining,dwFlags,pszFormat,argList);
 633     va_end(argList);
 634   }
 635   if(SUCCEEDED(hr) || (hr==STRSAFE_E_INSUFFICIENT_BUFFER)) {
 636     if(pcbRemaining) {
 637       *pcbRemaining = (cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t));
 638     }
 639   }
 640   return hr;
 641 }
 642 #endif /* !__CRT__NO_INLINE */
 643
 644 STRSAFEAPI StringCchVPrintfExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,va_list argList);
 645 STRSAFEAPI StringCchVPrintfExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,va_list argList);
 646
 647 #define StringCchVPrintfEx __MINGW_NAME_AW(StringCchVPrintfEx)
 648
 649 #ifndef __CRT__NO_INLINE
 650 STRSAFEAPI StringCchVPrintfExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,va_list argList) {
 651   HRESULT hr;
 652   if(cchDest > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
 653   else {
 654     size_t cbDest;
 655     cbDest = cchDest*sizeof(char);
 656     hr = StringVPrintfExWorkerA(pszDest,cchDest,cbDest,ppszDestEnd,pcchRemaining,dwFlags,pszFormat,argList);
 657   }
 658   return hr;
 659 }
 660
 661 STRSAFEAPI StringCchVPrintfExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,va_list argList) {
 662   HRESULT hr;
 663   if(cchDest > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
 664   else {
 665     size_t cbDest;
 666     cbDest = cchDest*sizeof(wchar_t);
 667     hr = StringVPrintfExWorkerW(pszDest,cchDest,cbDest,ppszDestEnd,pcchRemaining,dwFlags,pszFormat,argList);
 668   }
 669   return hr;
 670 }
 671 #endif /* !__CRT__NO_INLINE */
 672
 673 STRSAFEAPI StringCbVPrintfExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,va_list argList);
 674 STRSAFEAPI StringCbVPrintfExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,va_list argList);
 675
 676 #define StringCbVPrintfEx __MINGW_NAME_AW(StringCbVPrintfEx)
 677
 678 #ifndef __CRT__NO_INLINE
 679 STRSAFEAPI StringCbVPrintfExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,va_list argList) {
 680   HRESULT hr;
 681   size_t cchDest;
 682   size_t cchRemaining = 0;
 683   cchDest = cbDest / sizeof(char);
 684   if(cchDest > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
 685   else hr = StringVPrintfExWorkerA(pszDest,cchDest,cbDest,ppszDestEnd,&cchRemaining,dwFlags,pszFormat,argList);
 686   if(SUCCEEDED(hr) || (hr==STRSAFE_E_INSUFFICIENT_BUFFER)) {
 687     if(pcbRemaining) {
 688       *pcbRemaining = (cchRemaining*sizeof(char)) + (cbDest % sizeof(char));
 689     }
 690   }
 691   return hr;
 692 }
 693
 694 STRSAFEAPI StringCbVPrintfExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,va_list argList) {
 695   HRESULT hr;
 696   size_t cchDest;
 697   size_t cchRemaining = 0;
 698   cchDest = cbDest / sizeof(wchar_t);
 699   if(cchDest > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
 700   else hr = StringVPrintfExWorkerW(pszDest,cchDest,cbDest,ppszDestEnd,&cchRemaining,dwFlags,pszFormat,argList);
 701   if(SUCCEEDED(hr) || (hr==STRSAFE_E_INSUFFICIENT_BUFFER)) {
 702     if(pcbRemaining) {
 703       *pcbRemaining = (cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t));
 704     }
 705   }
 706   return hr;
 707 }
 708 #endif /* !__CRT__NO_INLINE */
 709
 710 STRSAFE_INLINE_API StringCchGetsA(STRSAFE_LPSTR pszDest,size_t cchDest);
 711 STRSAFE_INLINE_API StringCchGetsW(STRSAFE_LPWSTR pszDest,size_t cchDest);
 712
 713 #define StringCchGets __MINGW_NAME_AW(StringCchGets)
 714
 715 #ifndef __CRT__NO_INLINE
 716 STRSAFE_INLINE_API StringCchGetsA(STRSAFE_LPSTR pszDest,size_t cchDest) {
 717   HRESULT hr;
 718   if(cchDest > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
 719   else {
 720     size_t cbDest;
 721     cbDest = cchDest*sizeof(char);
 722     hr = StringGetsExWorkerA(pszDest,cchDest,cbDest,NULL,NULL,0);
 723   }
 724   return hr;
 725 }
 726
 727 STRSAFE_INLINE_API StringCchGetsW(STRSAFE_LPWSTR pszDest,size_t cchDest) {
 728   HRESULT hr;
 729   if(cchDest > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
 730   else {
 731     size_t cbDest;
 732     cbDest = cchDest*sizeof(wchar_t);
 733     hr = StringGetsExWorkerW(pszDest,cchDest,cbDest,NULL,NULL,0);
 734   }
 735   return hr;
 736 }
 737 #endif /* !__CRT__NO_INLINE */
 738
 739 STRSAFE_INLINE_API StringCbGetsA(STRSAFE_LPSTR pszDest,size_t cbDest);
 740 STRSAFE_INLINE_API StringCbGetsW(STRSAFE_LPWSTR pszDest,size_t cbDest);
 741
 742 #define StringCbGets __MINGW_NAME_AW(StringCbGets)
 743
 744 #ifndef __CRT__NO_INLINE
 745 STRSAFE_INLINE_API StringCbGetsA(STRSAFE_LPSTR pszDest,size_t cbDest) {
 746   HRESULT hr;
 747   size_t cchDest;
 748   cchDest = cbDest / sizeof(char);
 749   if(cchDest > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
 750   else hr = StringGetsExWorkerA(pszDest,cchDest,cbDest,NULL,NULL,0);
 751   return hr;
 752 }
 753
 754 STRSAFE_INLINE_API StringCbGetsW(STRSAFE_LPWSTR pszDest,size_t cbDest) {
 755   HRESULT hr;
 756   size_t cchDest;
 757   cchDest = cbDest / sizeof(wchar_t);
 758   if(cchDest > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
 759   else hr = StringGetsExWorkerW(pszDest,cchDest,cbDest,NULL,NULL,0);
 760   return hr;
 761 }
 762 #endif /* !__CRT__NO_INLINE */
 763
 764 STRSAFE_INLINE_API StringCchGetsExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 765 STRSAFE_INLINE_API StringCchGetsExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 766
 767 #define StringCchGetsEx __MINGW_NAME_AW(StringCchGetsEx)
 768
 769 #ifndef __CRT__NO_INLINE
 770 STRSAFE_INLINE_API StringCchGetsExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags) {
 771   HRESULT hr;
 772   if(cchDest > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
 773   else {
 774     size_t cbDest;
 775     cbDest = cchDest*sizeof(char);
 776     hr = StringGetsExWorkerA(pszDest,cchDest,cbDest,ppszDestEnd,pcchRemaining,dwFlags);
 777   }
 778   return hr;
 779 }
 780
 781 STRSAFE_INLINE_API StringCchGetsExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags) {
 782   HRESULT hr;
 783   if(cchDest > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
 784   else {
 785     size_t cbDest;
 786     cbDest = cchDest*sizeof(wchar_t);
 787     hr = StringGetsExWorkerW(pszDest,cchDest,cbDest,ppszDestEnd,pcchRemaining,dwFlags);
 788   }
 789   return hr;
 790 }
 791 #endif /* !__CRT__NO_INLINE */
 792
 793 STRSAFE_INLINE_API StringCbGetsExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
 794 STRSAFE_INLINE_API StringCbGetsExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
 795
 796 #define StringCbGetsEx __MINGW_NAME_AW(StringCbGetsEx)
 797
 798 #ifndef __CRT__NO_INLINE
 799 STRSAFE_INLINE_API StringCbGetsExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags) {
 800   HRESULT hr;
 801   size_t cchDest;
 802   size_t cchRemaining = 0;
 803   cchDest = cbDest / sizeof(char);
 804   if(cchDest > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
 805   else hr = StringGetsExWorkerA(pszDest,cchDest,cbDest,ppszDestEnd,&cchRemaining,dwFlags);
 806   if(SUCCEEDED(hr) || (hr==STRSAFE_E_INSUFFICIENT_BUFFER) || (hr==STRSAFE_E_END_OF_FILE)) {
 807     if(pcbRemaining) *pcbRemaining = (cchRemaining*sizeof(char)) + (cbDest % sizeof(char));
 808   }
 809   return hr;
 810 }
 811
 812 STRSAFE_INLINE_API StringCbGetsExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags) {
 813   HRESULT hr;
 814   size_t cchDest;
 815   size_t cchRemaining = 0;
 816   cchDest = cbDest / sizeof(wchar_t);
 817   if(cchDest > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
 818   else hr = StringGetsExWorkerW(pszDest,cchDest,cbDest,ppszDestEnd,&cchRemaining,dwFlags);
 819   if(SUCCEEDED(hr) || (hr==STRSAFE_E_INSUFFICIENT_BUFFER) || (hr==STRSAFE_E_END_OF_FILE)) {
 820     if(pcbRemaining) *pcbRemaining = (cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t));
 821   }
 822   return hr;
 823 }
 824 #endif /* !__CRT__NO_INLINE */
 825
 826 STRSAFEAPI StringCchLengthA(STRSAFE_LPCSTR psz,size_t cchMax,size_t *pcchLength);
 827 STRSAFEAPI StringCchLengthW(STRSAFE_LPCWSTR psz,size_t cchMax,size_t *pcchLength);
 828
 829 #define StringCchLength __MINGW_NAME_AW(StringCchLength)
 830
 831 #ifndef __CRT__NO_INLINE
 832 STRSAFEAPI StringCchLengthA(STRSAFE_LPCSTR psz,size_t cchMax,size_t *pcchLength) {
 833   HRESULT hr;
 834   if(!psz || (cchMax > STRSAFE_MAX_CCH)) hr = STRSAFE_E_INVALID_PARAMETER;
 835   else hr = StringLengthWorkerA(psz,cchMax,pcchLength);
 836   if(FAILED(hr) && pcchLength) {
 837     *pcchLength = 0;
 838   }
 839   return hr;
 840 }
 841
 842 STRSAFEAPI StringCchLengthW(STRSAFE_LPCWSTR psz,size_t cchMax,size_t *pcchLength) {
 843   HRESULT hr;
 844   if(!psz || (cchMax > STRSAFE_MAX_CCH)) hr = STRSAFE_E_INVALID_PARAMETER;
 845   else hr = StringLengthWorkerW(psz,cchMax,pcchLength);
 846   if(FAILED(hr) && pcchLength) {
 847     *pcchLength = 0;
 848   }
 849   return hr;
 850 }
 851 #endif /* !__CRT__NO_INLINE */
 852
 853 STRSAFEAPI StringCbLengthA(STRSAFE_LPCSTR psz,size_t cbMax,size_t *pcbLength);
 854 STRSAFEAPI StringCbLengthW(STRSAFE_LPCWSTR psz,size_t cbMax,size_t *pcbLength);
 855
 856 #define StringCbLength __MINGW_NAME_AW(StringCbLength)
 857
 858 #ifndef __CRT__NO_INLINE
 859 STRSAFEAPI StringCbLengthA(STRSAFE_LPCSTR psz,size_t cbMax,size_t *pcbLength) {
 860   HRESULT hr;
 861   size_t cchMax;
 862   size_t cchLength = 0;
 863   cchMax = cbMax / sizeof(char);
 864   if(!psz || (cchMax > STRSAFE_MAX_CCH)) hr = STRSAFE_E_INVALID_PARAMETER;
 865   else hr = StringLengthWorkerA(psz,cchMax,&cchLength);
 866   if(pcbLength) {
 867     if(SUCCEEDED(hr)) {
 868       *pcbLength = cchLength*sizeof(char);
 869     } else {
 870       *pcbLength = 0;
 871     }
 872   }
 873   return hr;
 874 }
 875
 876 STRSAFEAPI StringCbLengthW(STRSAFE_LPCWSTR psz,size_t cbMax,size_t *pcbLength) {
 877   HRESULT hr;
 878   size_t cchMax;
 879   size_t cchLength = 0;
 880   cchMax = cbMax / sizeof(wchar_t);
 881   if(!psz || (cchMax > STRSAFE_MAX_CCH)) hr = STRSAFE_E_INVALID_PARAMETER;
 882   else hr = StringLengthWorkerW(psz,cchMax,&cchLength);
 883   if(pcbLength) {
 884     if(SUCCEEDED(hr)) {
 885       *pcbLength = cchLength*sizeof(wchar_t);
 886     } else {
 887       *pcbLength = 0;
 888     }
 889   }
 890   return hr;
 891 }
 892
 893 STRSAFEAPI StringCopyWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc) {
 894   HRESULT hr = S_OK;
 895   if(cchDest==0) hr = STRSAFE_E_INVALID_PARAMETER;
 896   else {
 897     while(cchDest && (*pszSrc!='\0')) {
 898       *pszDest++ = *pszSrc++;
 899       cchDest--;
 900     }
 901     if(cchDest==0) {
 902       pszDest--;
 903       hr = STRSAFE_E_INSUFFICIENT_BUFFER;
 904     }
 905     *pszDest= '\0';
 906   }
 907   return hr;
 908 }
 909
 910 STRSAFEAPI StringCopyWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc) {
 911   HRESULT hr = S_OK;
 912   if(cchDest==0) hr = STRSAFE_E_INVALID_PARAMETER;
 913   else {
 914     while(cchDest && (*pszSrc!=L'\0')) {
 915       *pszDest++ = *pszSrc++;
 916       cchDest--;
 917     }
 918     if(cchDest==0) {
 919       pszDest--;
 920       hr = STRSAFE_E_INSUFFICIENT_BUFFER;
 921     }
 922     *pszDest= L'\0';
 923   }
 924   return hr;
 925 }
 926
 927 STRSAFEAPI StringCopyExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags) {
 928   HRESULT hr = S_OK;
 929   STRSAFE_LPSTR pszDestEnd = pszDest;
 930   size_t cchRemaining = 0;
 931   if(dwFlags & (~STRSAFE_VALID_FLAGS)) hr = STRSAFE_E_INVALID_PARAMETER;
 932   else {
 933     if(dwFlags & STRSAFE_IGNORE_NULLS) {
 934       if(!pszDest) {
 935         if((cchDest!=0) || (cbDest!=0)) hr = STRSAFE_E_INVALID_PARAMETER;
 936       }
 937       if(!pszSrc) pszSrc = "";
 938     }
 939     if(SUCCEEDED(hr)) {
 940       if(cchDest==0) {
 941         pszDestEnd = pszDest;
 942         cchRemaining = 0;
 943         if(*pszSrc!='\0') {
 944           if(!pszDest) hr = STRSAFE_E_INVALID_PARAMETER;
 945           else hr = STRSAFE_E_INSUFFICIENT_BUFFER;
 946         }
 947       } else {
 948         pszDestEnd = pszDest;
 949         cchRemaining = cchDest;
 950         while(cchRemaining && (*pszSrc!='\0')) {
 951           *pszDestEnd++ = *pszSrc++;
 952           cchRemaining--;
 953         }
 954         if(cchRemaining > 0) {
 955           if(dwFlags & STRSAFE_FILL_BEHIND_NULL) {
 956             memset(pszDestEnd + 1,STRSAFE_GET_FILL_PATTERN(dwFlags),((cchRemaining - 1)*sizeof(char)) + (cbDest % sizeof(char)));
 957           }
 958         } else {
 959           pszDestEnd--;
 960           cchRemaining++;
 961           hr = STRSAFE_E_INSUFFICIENT_BUFFER;
 962         }
 963         *pszDestEnd = '\0';
 964       }
 965     }
 966   }
 967   if(FAILED(hr)) {
 968     if(pszDest) {
 969       if(dwFlags & STRSAFE_FILL_ON_FAILURE) {
 970         memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
 971         if(STRSAFE_GET_FILL_PATTERN(dwFlags)==0) {
 972           pszDestEnd = pszDest;
 973           cchRemaining = cchDest;
 974         } else if(cchDest > 0) {
 975           pszDestEnd = pszDest + cchDest - 1;
 976           cchRemaining = 1;
 977           *pszDestEnd = '\0';
 978         }
 979       }
 980       if(dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION)) {
 981         if(cchDest > 0) {
 982           pszDestEnd = pszDest;
 983           cchRemaining = cchDest;
 984           *pszDestEnd = '\0';
 985         }
 986       }
 987     }
 988   }
 989   if(SUCCEEDED(hr) || (hr==STRSAFE_E_INSUFFICIENT_BUFFER)) {
 990     if(ppszDestEnd) *ppszDestEnd = pszDestEnd;
 991     if(pcchRemaining) *pcchRemaining = cchRemaining;
 992   }
 993   return hr;
 994 }
 995
 996 STRSAFEAPI StringCopyExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags) {
 997   HRESULT hr = S_OK;
 998   STRSAFE_LPWSTR pszDestEnd = pszDest;
 999   size_t cchRemaining = 0;
1000   if(dwFlags & (~STRSAFE_VALID_FLAGS)) hr = STRSAFE_E_INVALID_PARAMETER;
1001   else {
1002     if(dwFlags & STRSAFE_IGNORE_NULLS) {
1003       if(!pszDest) {
1004         if((cchDest!=0) || (cbDest!=0)) hr = STRSAFE_E_INVALID_PARAMETER;
1005       }
1006       if(!pszSrc) pszSrc = L"";
1007     }
1008     if(SUCCEEDED(hr)) {
1009       if(cchDest==0) {
1010         pszDestEnd = pszDest;
1011         cchRemaining = 0;
1012         if(*pszSrc!=L'\0') {
1013           if(!pszDest) hr = STRSAFE_E_INVALID_PARAMETER;
1014           else hr = STRSAFE_E_INSUFFICIENT_BUFFER;
1015         }
1016       } else {
1017         pszDestEnd = pszDest;
1018         cchRemaining = cchDest;
1019         while(cchRemaining && (*pszSrc!=L'\0')) {
1020           *pszDestEnd++ = *pszSrc++;
1021           cchRemaining--;
1022         }
1023         if(cchRemaining > 0) {
1024           if(dwFlags & STRSAFE_FILL_BEHIND_NULL) {
1025             memset(pszDestEnd + 1,STRSAFE_GET_FILL_PATTERN(dwFlags),((cchRemaining - 1)*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t)));
1026           }
1027         } else {
1028           pszDestEnd--;
1029           cchRemaining++;
1030           hr = STRSAFE_E_INSUFFICIENT_BUFFER;
1031         }
1032         *pszDestEnd = L'\0';
1033       }
1034     }
1035   }
1036   if(FAILED(hr)) {
1037     if(pszDest) {
1038       if(dwFlags & STRSAFE_FILL_ON_FAILURE) {
1039         memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
1040         if(STRSAFE_GET_FILL_PATTERN(dwFlags)==0) {
1041           pszDestEnd = pszDest;
1042           cchRemaining = cchDest;
1043         } else if(cchDest > 0) {
1044           pszDestEnd = pszDest + cchDest - 1;
1045           cchRemaining = 1;
1046           *pszDestEnd = L'\0';
1047         }
1048       }
1049       if(dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION)) {
1050         if(cchDest > 0) {
1051           pszDestEnd = pszDest;
1052           cchRemaining = cchDest;
1053           *pszDestEnd = L'\0';
1054         }
1055       }
1056     }
1057   }
1058   if(SUCCEEDED(hr) || (hr==STRSAFE_E_INSUFFICIENT_BUFFER)) {
1059     if(ppszDestEnd) *ppszDestEnd = pszDestEnd;
1060     if(pcchRemaining) *pcchRemaining = cchRemaining;
1061   }
1062   return hr;
1063 }
1064
1065 STRSAFEAPI StringCopyNWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchSrc) {
1066   HRESULT hr = S_OK;
1067   if(cchDest==0) hr = STRSAFE_E_INVALID_PARAMETER;
1068   else {
1069     while(cchDest && cchSrc && (*pszSrc!='\0')) {
1070       *pszDest++ = *pszSrc++;
1071       cchDest--;
1072       cchSrc--;
1073     }
1074     if(cchDest==0) {
1075       pszDest--;
1076       hr = STRSAFE_E_INSUFFICIENT_BUFFER;
1077     }
1078     *pszDest= '\0';
1079   }
1080   return hr;
1081 }
1082
1083 STRSAFEAPI StringCopyNWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy) {
1084   HRESULT hr = S_OK;
1085   if(cchDest==0) hr = STRSAFE_E_INVALID_PARAMETER;
1086   else {
1087     while(cchDest && cchToCopy && (*pszSrc!=L'\0')) {
1088       *pszDest++ = *pszSrc++;
1089       cchDest--;
1090       cchToCopy--;
1091     }
1092     if(cchDest==0) {
1093       pszDest--;
1094       hr = STRSAFE_E_INSUFFICIENT_BUFFER;
1095     }
1096     *pszDest= L'\0';
1097   }
1098   return hr;
1099 }
1100
1101 STRSAFEAPI StringCopyNExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cchToCopy,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags) {
1102   HRESULT hr = S_OK;
1103   STRSAFE_LPSTR pszDestEnd = pszDest;
1104   size_t cchRemaining = 0;
1105   if(dwFlags & (~STRSAFE_VALID_FLAGS)) hr = STRSAFE_E_INVALID_PARAMETER;
1106   else if(cchToCopy > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
1107   else {
1108     if(dwFlags & STRSAFE_IGNORE_NULLS) {
1109       if(!pszDest) {
1110         if((cchDest!=0) || (cbDest!=0)) hr = STRSAFE_E_INVALID_PARAMETER;
1111       }
1112       if(!pszSrc) pszSrc = "";
1113     }
1114     if(SUCCEEDED(hr)) {
1115       if(cchDest==0) {
1116         pszDestEnd = pszDest;
1117         cchRemaining = 0;
1118         if((cchToCopy!=0) && (*pszSrc!='\0')) {
1119           if(!pszDest) hr = STRSAFE_E_INVALID_PARAMETER;
1120           else hr = STRSAFE_E_INSUFFICIENT_BUFFER;
1121         }
1122       } else {
1123         pszDestEnd = pszDest;
1124         cchRemaining = cchDest;
1125         while(cchRemaining && cchToCopy && (*pszSrc!='\0')) {
1126           *pszDestEnd++ = *pszSrc++;
1127           cchRemaining--;
1128           cchToCopy--;
1129         }
1130         if(cchRemaining > 0) {
1131           if(dwFlags & STRSAFE_FILL_BEHIND_NULL) {
1132             memset(pszDestEnd + 1,STRSAFE_GET_FILL_PATTERN(dwFlags),((cchRemaining - 1)*sizeof(char)) + (cbDest % sizeof(char)));
1133           }
1134         } else {
1135           pszDestEnd--;
1136           cchRemaining++;
1137           hr = STRSAFE_E_INSUFFICIENT_BUFFER;
1138         }
1139         *pszDestEnd = '\0';
1140       }
1141     }
1142   }
1143   if(FAILED(hr)) {
1144     if(pszDest) {
1145       if(dwFlags & STRSAFE_FILL_ON_FAILURE) {
1146         memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
1147         if(STRSAFE_GET_FILL_PATTERN(dwFlags)==0) {
1148           pszDestEnd = pszDest;
1149           cchRemaining = cchDest;
1150         } else if(cchDest > 0) {
1151           pszDestEnd = pszDest + cchDest - 1;
1152           cchRemaining = 1;
1153           *pszDestEnd = '\0';
1154         }
1155       }
1156       if(dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION)) {
1157         if(cchDest > 0) {
1158           pszDestEnd = pszDest;
1159           cchRemaining = cchDest;
1160           *pszDestEnd = '\0';
1161         }
1162       }
1163     }
1164   }
1165   if(SUCCEEDED(hr) || (hr==STRSAFE_E_INSUFFICIENT_BUFFER)) {
1166     if(ppszDestEnd) *ppszDestEnd = pszDestEnd;
1167     if(pcchRemaining) *pcchRemaining = cchRemaining;
1168   }
1169   return hr;
1170 }
1171
1172 STRSAFEAPI StringCopyNExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags) {
1173   HRESULT hr = S_OK;
1174   STRSAFE_LPWSTR pszDestEnd = pszDest;
1175   size_t cchRemaining = 0;
1176   if(dwFlags & (~STRSAFE_VALID_FLAGS)) hr = STRSAFE_E_INVALID_PARAMETER;
1177   else if(cchToCopy > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
1178   else {
1179     if(dwFlags & STRSAFE_IGNORE_NULLS) {
1180       if(!pszDest) {
1181         if((cchDest!=0) || (cbDest!=0)) hr = STRSAFE_E_INVALID_PARAMETER;
1182       }
1183       if(!pszSrc) pszSrc = L"";
1184     }
1185     if(SUCCEEDED(hr)) {
1186       if(cchDest==0) {
1187         pszDestEnd = pszDest;
1188         cchRemaining = 0;
1189         if((cchToCopy!=0) && (*pszSrc!=L'\0')) {
1190           if(!pszDest) hr = STRSAFE_E_INVALID_PARAMETER;
1191           else hr = STRSAFE_E_INSUFFICIENT_BUFFER;
1192         }
1193       } else {
1194         pszDestEnd = pszDest;
1195         cchRemaining = cchDest;
1196         while(cchRemaining && cchToCopy && (*pszSrc!=L'\0')) {
1197           *pszDestEnd++ = *pszSrc++;
1198           cchRemaining--;
1199           cchToCopy--;
1200         }
1201         if(cchRemaining > 0) {
1202           if(dwFlags & STRSAFE_FILL_BEHIND_NULL) {
1203             memset(pszDestEnd + 1,STRSAFE_GET_FILL_PATTERN(dwFlags),((cchRemaining - 1)*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t)));
1204           }
1205         } else {
1206           pszDestEnd--;
1207           cchRemaining++;
1208           hr = STRSAFE_E_INSUFFICIENT_BUFFER;
1209         }
1210         *pszDestEnd = L'\0';
1211       }
1212     }
1213   }
1214   if(FAILED(hr)) {
1215     if(pszDest) {
1216       if(dwFlags & STRSAFE_FILL_ON_FAILURE) {
1217         memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
1218         if(STRSAFE_GET_FILL_PATTERN(dwFlags)==0) {
1219           pszDestEnd = pszDest;
1220           cchRemaining = cchDest;
1221         } else if(cchDest > 0) {
1222           pszDestEnd = pszDest + cchDest - 1;
1223           cchRemaining = 1;
1224           *pszDestEnd = L'\0';
1225         }
1226       }
1227       if(dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION)) {
1228         if(cchDest > 0) {
1229           pszDestEnd = pszDest;
1230           cchRemaining = cchDest;
1231           *pszDestEnd = L'\0';
1232         }
1233       }
1234     }
1235   }
1236   if(SUCCEEDED(hr) || (hr==STRSAFE_E_INSUFFICIENT_BUFFER)) {
1237     if(ppszDestEnd) *ppszDestEnd = pszDestEnd;
1238     if(pcchRemaining) *pcchRemaining = cchRemaining;
1239   }
1240   return hr;
1241 }
1242
1243 STRSAFEAPI StringCatWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc) {
1244   HRESULT hr;
1245   size_t cchDestLength;
1246   hr = StringLengthWorkerA(pszDest,cchDest,&cchDestLength);
1247   if(SUCCEEDED(hr)) hr = StringCopyWorkerA(pszDest + cchDestLength,cchDest - cchDestLength,pszSrc);
1248   return hr;
1249 }
1250
1251 STRSAFEAPI StringCatWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc) {
1252   HRESULT hr;
1253   size_t cchDestLength;
1254   hr = StringLengthWorkerW(pszDest,cchDest,&cchDestLength);
1255   if(SUCCEEDED(hr)) hr = StringCopyWorkerW(pszDest + cchDestLength,cchDest - cchDestLength,pszSrc);
1256   return hr;
1257 }
1258
1259 STRSAFEAPI StringCatExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags) {
1260   HRESULT hr = S_OK;
1261   STRSAFE_LPSTR pszDestEnd = pszDest;
1262   size_t cchRemaining = 0;
1263   if(dwFlags & (~STRSAFE_VALID_FLAGS)) hr = STRSAFE_E_INVALID_PARAMETER;
1264   else {
1265     size_t cchDestLength;
1266     if(dwFlags & STRSAFE_IGNORE_NULLS) {
1267       if(!pszDest) {
1268         if((cchDest==0) && (cbDest==0)) cchDestLength = 0;
1269         else hr = STRSAFE_E_INVALID_PARAMETER;
1270       } else {
1271         hr = StringLengthWorkerA(pszDest,cchDest,&cchDestLength);
1272         if(SUCCEEDED(hr)) {
1273           pszDestEnd = pszDest + cchDestLength;
1274           cchRemaining = cchDest - cchDestLength;
1275         }
1276       }
1277       if(!pszSrc) pszSrc = "";
1278     } else {
1279       hr = StringLengthWorkerA(pszDest,cchDest,&cchDestLength);
1280       if(SUCCEEDED(hr)) {
1281         pszDestEnd = pszDest + cchDestLength;
1282         cchRemaining = cchDest - cchDestLength;
1283       }
1284     }
1285     if(SUCCEEDED(hr)) {
1286       if(cchDest==0) {
1287         if(*pszSrc!='\0') {
1288           if(!pszDest) hr = STRSAFE_E_INVALID_PARAMETER;
1289           else hr = STRSAFE_E_INSUFFICIENT_BUFFER;
1290         }
1291       } else hr = StringCopyExWorkerA(pszDestEnd,cchRemaining,(cchRemaining*sizeof(char)) + (cbDest % sizeof(char)),pszSrc,&pszDestEnd,&cchRemaining,dwFlags & (~(STRSAFE_FILL_ON_FAILURE | STRSAFE_NULL_ON_FAILURE)));
1292     }
1293   }
1294   if(FAILED(hr)) {
1295     if(pszDest) {
1296       if(dwFlags & STRSAFE_FILL_ON_FAILURE) {
1297         memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
1298         if(STRSAFE_GET_FILL_PATTERN(dwFlags)==0) {
1299           pszDestEnd = pszDest;
1300           cchRemaining = cchDest;
1301         } else if(cchDest > 0) {
1302           pszDestEnd = pszDest + cchDest - 1;
1303           cchRemaining = 1;
1304           *pszDestEnd = '\0';
1305         }
1306       }
1307       if(dwFlags & STRSAFE_NULL_ON_FAILURE) {
1308         if(cchDest > 0) {
1309           pszDestEnd = pszDest;
1310           cchRemaining = cchDest;
1311           *pszDestEnd = '\0';
1312         }
1313       }
1314     }
1315   }
1316   if(SUCCEEDED(hr) || (hr==STRSAFE_E_INSUFFICIENT_BUFFER)) {
1317     if(ppszDestEnd) *ppszDestEnd = pszDestEnd;
1318     if(pcchRemaining) *pcchRemaining = cchRemaining;
1319   }
1320   return hr;
1321 }
1322
1323 STRSAFEAPI StringCatExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags) {
1324   HRESULT hr = S_OK;
1325   STRSAFE_LPWSTR pszDestEnd = pszDest;
1326   size_t cchRemaining = 0;
1327   if(dwFlags & (~STRSAFE_VALID_FLAGS)) hr = STRSAFE_E_INVALID_PARAMETER;
1328   else {
1329     size_t cchDestLength;
1330     if(dwFlags & STRSAFE_IGNORE_NULLS) {
1331       if(!pszDest) {
1332         if((cchDest==0) && (cbDest==0)) cchDestLength = 0;
1333         else hr = STRSAFE_E_INVALID_PARAMETER;
1334       } else {
1335         hr = StringLengthWorkerW(pszDest,cchDest,&cchDestLength);
1336         if(SUCCEEDED(hr)) {
1337           pszDestEnd = pszDest + cchDestLength;
1338           cchRemaining = cchDest - cchDestLength;
1339         }
1340       }
1341       if(!pszSrc) pszSrc = L"";
1342     } else {
1343       hr = StringLengthWorkerW(pszDest,cchDest,&cchDestLength);
1344       if(SUCCEEDED(hr)) {
1345         pszDestEnd = pszDest + cchDestLength;
1346         cchRemaining = cchDest - cchDestLength;
1347       }
1348     }
1349     if(SUCCEEDED(hr)) {
1350       if(cchDest==0) {
1351         if(*pszSrc!=L'\0') {
1352           if(!pszDest) hr = STRSAFE_E_INVALID_PARAMETER;
1353           else hr = STRSAFE_E_INSUFFICIENT_BUFFER;
1354         }
1355       } else hr = StringCopyExWorkerW(pszDestEnd,cchRemaining,(cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t)),pszSrc,&pszDestEnd,&cchRemaining,dwFlags & (~(STRSAFE_FILL_ON_FAILURE | STRSAFE_NULL_ON_FAILURE)));
1356     }
1357   }
1358   if(FAILED(hr)) {
1359     if(pszDest) {
1360       if(dwFlags & STRSAFE_FILL_ON_FAILURE) {
1361         memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
1362         if(STRSAFE_GET_FILL_PATTERN(dwFlags)==0) {
1363           pszDestEnd = pszDest;
1364           cchRemaining = cchDest;
1365         } else if(cchDest > 0) {
1366           pszDestEnd = pszDest + cchDest - 1;
1367           cchRemaining = 1;
1368           *pszDestEnd = L'\0';
1369         }
1370       }
1371       if(dwFlags & STRSAFE_NULL_ON_FAILURE) {
1372         if(cchDest > 0) {
1373           pszDestEnd = pszDest;
1374           cchRemaining = cchDest;
1375           *pszDestEnd = L'\0';
1376         }
1377       }
1378     }
1379   }
1380   if(SUCCEEDED(hr) || (hr==STRSAFE_E_INSUFFICIENT_BUFFER)) {
1381     if(ppszDestEnd) *ppszDestEnd = pszDestEnd;
1382     if(pcchRemaining) *pcchRemaining = cchRemaining;
1383   }
1384   return hr;
1385 }
1386
1387 STRSAFEAPI StringCatNWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend) {
1388   HRESULT hr;
1389   size_t cchDestLength;
1390   hr = StringLengthWorkerA(pszDest,cchDest,&cchDestLength);
1391   if(SUCCEEDED(hr)) hr = StringCopyNWorkerA(pszDest + cchDestLength,cchDest - cchDestLength,pszSrc,cchToAppend);
1392   return hr;
1393 }
1394
1395 STRSAFEAPI StringCatNWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend) {
1396   HRESULT hr;
1397   size_t cchDestLength;
1398   hr = StringLengthWorkerW(pszDest,cchDest,&cchDestLength);
1399   if(SUCCEEDED(hr)) hr = StringCopyNWorkerW(pszDest + cchDestLength,cchDest - cchDestLength,pszSrc,cchToAppend);
1400   return hr;
1401 }
1402
1403 STRSAFEAPI StringCatNExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags) {
1404   HRESULT hr = S_OK;
1405   STRSAFE_LPSTR pszDestEnd = pszDest;
1406   size_t cchRemaining = 0;
1407   size_t cchDestLength = 0;
1408   if(dwFlags & (~STRSAFE_VALID_FLAGS)) hr = STRSAFE_E_INVALID_PARAMETER;
1409   else if(cchToAppend > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
1410   else {
1411     if(dwFlags & STRSAFE_IGNORE_NULLS) {
1412       if(!pszDest) {
1413         if((cchDest==0) && (cbDest==0)) cchDestLength = 0;
1414         else hr = STRSAFE_E_INVALID_PARAMETER;
1415       } else {
1416         hr = StringLengthWorkerA(pszDest,cchDest,&cchDestLength);
1417         if(SUCCEEDED(hr)) {
1418           pszDestEnd = pszDest + cchDestLength;
1419           cchRemaining = cchDest - cchDestLength;
1420         }
1421       }
1422       if(!pszSrc) pszSrc = "";
1423     } else {
1424       hr = StringLengthWorkerA(pszDest,cchDest,&cchDestLength);
1425       if(SUCCEEDED(hr)) {
1426         pszDestEnd = pszDest + cchDestLength;
1427         cchRemaining = cchDest - cchDestLength;
1428       }
1429     }
1430     if(SUCCEEDED(hr)) {
1431       if(cchDest==0) {
1432         if((cchToAppend!=0) && (*pszSrc!='\0')) {
1433           if(!pszDest) hr = STRSAFE_E_INVALID_PARAMETER;
1434           else hr = STRSAFE_E_INSUFFICIENT_BUFFER;
1435         }
1436       } else hr = StringCopyNExWorkerA(pszDestEnd,cchRemaining,(cchRemaining*sizeof(char)) + (cbDest % sizeof(char)),pszSrc,cchToAppend,&pszDestEnd,&cchRemaining,dwFlags & (~(STRSAFE_FILL_ON_FAILURE | STRSAFE_NULL_ON_FAILURE)));
1437     }
1438   }
1439   if(FAILED(hr)) {
1440     if(pszDest) {
1441       if(dwFlags & STRSAFE_FILL_ON_FAILURE) {
1442         memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
1443         if(STRSAFE_GET_FILL_PATTERN(dwFlags)==0) {
1444           pszDestEnd = pszDest;
1445           cchRemaining = cchDest;
1446         } else if(cchDest > 0) {
1447           pszDestEnd = pszDest + cchDest - 1;
1448           cchRemaining = 1;
1449           *pszDestEnd = '\0';
1450         }
1451       }
1452       if(dwFlags & (STRSAFE_NULL_ON_FAILURE)) {
1453         if(cchDest > 0) {
1454           pszDestEnd = pszDest;
1455           cchRemaining = cchDest;
1456           *pszDestEnd = '\0';
1457         }
1458       }
1459     }
1460   }
1461   if(SUCCEEDED(hr) || (hr==STRSAFE_E_INSUFFICIENT_BUFFER)) {
1462     if(ppszDestEnd) *ppszDestEnd = pszDestEnd;
1463     if(pcchRemaining) *pcchRemaining = cchRemaining;
1464   }
1465   return hr;
1466 }
1467
1468 STRSAFEAPI StringCatNExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags) {
1469   HRESULT hr = S_OK;
1470   STRSAFE_LPWSTR pszDestEnd = pszDest;
1471   size_t cchRemaining = 0;
1472   size_t cchDestLength = 0;
1473   if(dwFlags & (~STRSAFE_VALID_FLAGS)) hr = STRSAFE_E_INVALID_PARAMETER;
1474   else if(cchToAppend > STRSAFE_MAX_CCH) hr = STRSAFE_E_INVALID_PARAMETER;
1475   else {
1476     if(dwFlags & STRSAFE_IGNORE_NULLS) {
1477       if(!pszDest) {
1478         if((cchDest==0) && (cbDest==0)) cchDestLength = 0;
1479         else hr = STRSAFE_E_INVALID_PARAMETER;
1480       } else {
1481         hr = StringLengthWorkerW(pszDest,cchDest,&cchDestLength);
1482         if(SUCCEEDED(hr)) {
1483           pszDestEnd = pszDest + cchDestLength;
1484           cchRemaining = cchDest - cchDestLength;
1485         }
1486       }
1487       if(!pszSrc) pszSrc = L"";
1488     } else {
1489       hr = StringLengthWorkerW(pszDest,cchDest,&cchDestLength);
1490       if(SUCCEEDED(hr)) {
1491         pszDestEnd = pszDest + cchDestLength;
1492         cchRemaining = cchDest - cchDestLength;
1493       }
1494     }
1495     if(SUCCEEDED(hr)) {
1496       if(cchDest==0) {
1497         if((cchToAppend!=0) && (*pszSrc!=L'\0')) {
1498           if(!pszDest) hr = STRSAFE_E_INVALID_PARAMETER;
1499           else hr = STRSAFE_E_INSUFFICIENT_BUFFER;
1500         }
1501       } else hr = StringCopyNExWorkerW(pszDestEnd,cchRemaining,(cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t)),pszSrc,cchToAppend,&pszDestEnd,&cchRemaining,dwFlags & (~(STRSAFE_FILL_ON_FAILURE | STRSAFE_NULL_ON_FAILURE)));
1502     }
1503   }
1504   if(FAILED(hr)) {
1505     if(pszDest) {
1506       if(dwFlags & STRSAFE_FILL_ON_FAILURE) {
1507         memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
1508         if(STRSAFE_GET_FILL_PATTERN(dwFlags)==0) {
1509           pszDestEnd = pszDest;
1510           cchRemaining = cchDest;
1511         } else if(cchDest > 0) {
1512           pszDestEnd = pszDest + cchDest - 1;
1513           cchRemaining = 1;
1514           *pszDestEnd = L'\0';
1515         }
1516       }
1517       if(dwFlags & (STRSAFE_NULL_ON_FAILURE)) {
1518         if(cchDest > 0) {
1519           pszDestEnd = pszDest;
1520           cchRemaining = cchDest;
1521           *pszDestEnd = L'\0';
1522         }
1523       }
1524     }
1525   }
1526   if(SUCCEEDED(hr) || (hr==STRSAFE_E_INSUFFICIENT_BUFFER)) {
1527     if(ppszDestEnd) *ppszDestEnd = pszDestEnd;
1528     if(pcchRemaining) *pcchRemaining = cchRemaining;
1529   }
1530   return hr;
1531 }
1532
1533 STRSAFEAPI StringVPrintfWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszFormat,va_list argList) {
1534   HRESULT hr = S_OK;
1535   if(cchDest==0) hr = STRSAFE_E_INVALID_PARAMETER;
1536   else {
1537     int iRet;
1538     size_t cchMax;
1539     cchMax = cchDest - 1;
1540     iRet = _vsnprintf(pszDest,cchMax,pszFormat,argList);
1541     if((iRet < 0) || (((size_t)iRet) > cchMax)) {
1542       pszDest += cchMax;
1543       *pszDest = '\0';
1544       hr = STRSAFE_E_INSUFFICIENT_BUFFER;
1545     } else if(((size_t)iRet)==cchMax) {
1546       pszDest += cchMax;
1547       *pszDest = '\0';
1548     }
1549   }
1550   return hr;
1551 }
1552
1553 STRSAFEAPI StringVPrintfWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszFormat,va_list argList) {
1554   HRESULT hr = S_OK;
1555   if(cchDest==0) hr = STRSAFE_E_INVALID_PARAMETER;
1556   else {
1557     int iRet;
1558     size_t cchMax;
1559     cchMax = cchDest - 1;
1560     iRet = _vsnwprintf(pszDest,cchMax,pszFormat,argList);
1561     if((iRet < 0) || (((size_t)iRet) > cchMax)) {
1562       pszDest += cchMax;
1563       *pszDest = L'\0';
1564       hr = STRSAFE_E_INSUFFICIENT_BUFFER;
1565     } else if(((size_t)iRet)==cchMax) {
1566       pszDest += cchMax;
1567       *pszDest = L'\0';
1568     }
1569   }
1570   return hr;
1571 }
1572
1573 STRSAFEAPI StringVPrintfExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,va_list argList) {
1574   HRESULT hr = S_OK;
1575   STRSAFE_LPSTR pszDestEnd = pszDest;
1576   size_t cchRemaining = 0;
1577   if(dwFlags & (~STRSAFE_VALID_FLAGS)) hr = STRSAFE_E_INVALID_PARAMETER;
1578   else {
1579     if(dwFlags & STRSAFE_IGNORE_NULLS) {
1580       if(!pszDest) {
1581         if((cchDest!=0) || (cbDest!=0)) hr = STRSAFE_E_INVALID_PARAMETER;
1582       }
1583       if(!pszFormat) pszFormat = "";
1584     }
1585     if(SUCCEEDED(hr)) {
1586       if(cchDest==0) {
1587         pszDestEnd = pszDest;
1588         cchRemaining = 0;
1589         if(*pszFormat!='\0') {
1590           if(!pszDest) hr = STRSAFE_E_INVALID_PARAMETER;
1591           else hr = STRSAFE_E_INSUFFICIENT_BUFFER;
1592         }
1593       } else {
1594         int iRet;
1595         size_t cchMax;
1596         cchMax = cchDest - 1;
1597         iRet = _vsnprintf(pszDest,cchMax,pszFormat,argList);
1598         if((iRet < 0) || (((size_t)iRet) > cchMax)) {
1599           pszDestEnd = pszDest + cchMax;
1600           cchRemaining = 1;
1601           *pszDestEnd = '\0';
1602           hr = STRSAFE_E_INSUFFICIENT_BUFFER;
1603         } else if(((size_t)iRet)==cchMax) {
1604           pszDestEnd = pszDest + cchMax;
1605           cchRemaining = 1;
1606           *pszDestEnd = '\0';
1607         } else if(((size_t)iRet) < cchMax) {
1608           pszDestEnd = pszDest + iRet;
1609           cchRemaining = cchDest - iRet;
1610           if(dwFlags & STRSAFE_FILL_BEHIND_NULL) {
1611             memset(pszDestEnd + 1,STRSAFE_GET_FILL_PATTERN(dwFlags),((cchRemaining - 1)*sizeof(char)) + (cbDest % sizeof(char)));
1612           }
1613         }
1614       }
1615     }
1616   }
1617   if(FAILED(hr)) {
1618     if(pszDest) {
1619       if(dwFlags & STRSAFE_FILL_ON_FAILURE) {
1620         memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
1621         if(STRSAFE_GET_FILL_PATTERN(dwFlags)==0) {
1622           pszDestEnd = pszDest;
1623           cchRemaining = cchDest;
1624         } else if(cchDest > 0) {
1625           pszDestEnd = pszDest + cchDest - 1;
1626           cchRemaining = 1;
1627           *pszDestEnd = '\0';
1628         }
1629       }
1630       if(dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION)) {
1631         if(cchDest > 0) {
1632           pszDestEnd = pszDest;
1633           cchRemaining = cchDest;
1634           *pszDestEnd = '\0';
1635         }
1636       }
1637     }
1638   }
1639   if(SUCCEEDED(hr) || (hr==STRSAFE_E_INSUFFICIENT_BUFFER)) {
1640     if(ppszDestEnd) *ppszDestEnd = pszDestEnd;
1641     if(pcchRemaining) *pcchRemaining = cchRemaining;
1642   }
1643   return hr;
1644 }
1645
1646 STRSAFEAPI StringVPrintfExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,va_list argList) {
1647   HRESULT hr = S_OK;
1648   STRSAFE_LPWSTR pszDestEnd = pszDest;
1649   size_t cchRemaining = 0;
1650   if(dwFlags & (~STRSAFE_VALID_FLAGS)) hr = STRSAFE_E_INVALID_PARAMETER;
1651   else {
1652     if(dwFlags & STRSAFE_IGNORE_NULLS) {
1653       if(!pszDest) {
1654         if((cchDest!=0) || (cbDest!=0)) hr = STRSAFE_E_INVALID_PARAMETER;
1655       }
1656       if(!pszFormat) pszFormat = L"";
1657     }
1658     if(SUCCEEDED(hr)) {
1659       if(cchDest==0) {
1660         pszDestEnd = pszDest;
1661         cchRemaining = 0;
1662         if(*pszFormat!=L'\0') {
1663           if(!pszDest) hr = STRSAFE_E_INVALID_PARAMETER;
1664           else hr = STRSAFE_E_INSUFFICIENT_BUFFER;
1665         }
1666       } else {
1667         int iRet;
1668         size_t cchMax;
1669         cchMax = cchDest - 1;
1670         iRet = _vsnwprintf(pszDest,cchMax,pszFormat,argList);
1671         if((iRet < 0) || (((size_t)iRet) > cchMax)) {
1672           pszDestEnd = pszDest + cchMax;
1673           cchRemaining = 1;
1674           *pszDestEnd = L'\0';
1675           hr = STRSAFE_E_INSUFFICIENT_BUFFER;
1676         } else if(((size_t)iRet)==cchMax) {
1677           pszDestEnd = pszDest + cchMax;
1678           cchRemaining = 1;
1679           *pszDestEnd = L'\0';
1680         } else if(((size_t)iRet) < cchMax) {
1681           pszDestEnd = pszDest + iRet;
1682           cchRemaining = cchDest - iRet;
1683           if(dwFlags & STRSAFE_FILL_BEHIND_NULL) {
1684             memset(pszDestEnd + 1,STRSAFE_GET_FILL_PATTERN(dwFlags),((cchRemaining - 1)*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t)));
1685           }
1686         }
1687       }
1688     }
1689   }
1690   if(FAILED(hr)) {
1691     if(pszDest) {
1692       if(dwFlags & STRSAFE_FILL_ON_FAILURE) {
1693         memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
1694         if(STRSAFE_GET_FILL_PATTERN(dwFlags)==0) {
1695           pszDestEnd = pszDest;
1696           cchRemaining = cchDest;
1697         } else if(cchDest > 0) {
1698           pszDestEnd = pszDest + cchDest - 1;
1699           cchRemaining = 1;
1700           *pszDestEnd = L'\0';
1701         }
1702       }
1703       if(dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION)) {
1704         if(cchDest > 0) {
1705           pszDestEnd = pszDest;
1706           cchRemaining = cchDest;
1707           *pszDestEnd = L'\0';
1708         }
1709       }
1710     }
1711   }
1712   if(SUCCEEDED(hr) || (hr==STRSAFE_E_INSUFFICIENT_BUFFER)) {
1713     if(ppszDestEnd) *ppszDestEnd = pszDestEnd;
1714     if(pcchRemaining) *pcchRemaining = cchRemaining;
1715   }
1716   return hr;
1717 }
1718
1719 STRSAFEAPI StringLengthWorkerA(STRSAFE_LPCSTR psz,size_t cchMax,size_t *pcchLength) {
1720   HRESULT hr = S_OK;
1721   size_t cchMaxPrev = cchMax;
1722   while(cchMax && (*psz!='\0')) {
1723     psz++;
1724     cchMax--;
1725   }
1726   if(cchMax==0) hr = STRSAFE_E_INVALID_PARAMETER;
1727   if(pcchLength) {
1728     if(SUCCEEDED(hr)) *pcchLength = cchMaxPrev - cchMax;
1729     else *pcchLength = 0;
1730   }
1731   return hr;
1732 }
1733
1734 STRSAFEAPI StringLengthWorkerW(STRSAFE_LPCWSTR psz,size_t cchMax,size_t *pcchLength) {
1735   HRESULT hr = S_OK;
1736   size_t cchMaxPrev = cchMax;
1737   while(cchMax && (*psz!=L'\0')) {
1738     psz++;
1739     cchMax--;
1740   }
1741   if(cchMax==0) hr = STRSAFE_E_INVALID_PARAMETER;
1742   if(pcchLength) {
1743     if(SUCCEEDED(hr)) *pcchLength = cchMaxPrev - cchMax;
1744     else *pcchLength = 0;
1745   }
1746   return hr;
1747 }
1748
1749 STRSAFE_INLINE_API StringGetsExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags) {
1750   HRESULT hr = S_OK;
1751   STRSAFE_LPSTR pszDestEnd = pszDest;
1752   size_t cchRemaining = 0;
1753
1754   if(dwFlags & (~STRSAFE_VALID_FLAGS)) hr = STRSAFE_E_INVALID_PARAMETER;
1755   else {
1756     if(dwFlags & STRSAFE_IGNORE_NULLS) {
1757       if(!pszDest) {
1758         if((cchDest!=0) || (cbDest!=0)) hr = STRSAFE_E_INVALID_PARAMETER;
1759       }
1760     }
1761     if(SUCCEEDED(hr)) {
1762       if(cchDest <= 1) {
1763         pszDestEnd = pszDest;
1764         cchRemaining = cchDest;
1765         if(cchDest==1) *pszDestEnd = '\0';
1766         hr = STRSAFE_E_INSUFFICIENT_BUFFER;
1767       } else {
1768         pszDestEnd = pszDest;
1769         cchRemaining = cchDest;
1770         while(cchRemaining > 1) {
1771           char ch;
1772           int i = getc(stdin);
1773           if(i==EOF) {
1774             if(pszDestEnd==pszDest) hr = STRSAFE_E_END_OF_FILE;
1775             break;
1776           }
1777           ch = (char)i;
1778           if(ch=='\n') break;
1779           *pszDestEnd = ch;
1780           pszDestEnd++;
1781           cchRemaining--;
1782         }
1783         if(cchRemaining > 0) {
1784           if(dwFlags & STRSAFE_FILL_BEHIND_NULL) {
1785             memset(pszDestEnd + 1,STRSAFE_GET_FILL_PATTERN(dwFlags),((cchRemaining - 1)*sizeof(char)) + (cbDest % sizeof(char)));
1786           }
1787         }
1788         *pszDestEnd = '\0';
1789       }
1790     }
1791   }
1792   if(FAILED(hr)) {
1793     if(pszDest) {
1794       if(dwFlags & STRSAFE_FILL_ON_FAILURE) {
1795         memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
1796         if(STRSAFE_GET_FILL_PATTERN(dwFlags)==0) {
1797           pszDestEnd = pszDest;
1798           cchRemaining = cchDest;
1799         } else if(cchDest > 0) {
1800           pszDestEnd = pszDest + cchDest - 1;
1801           cchRemaining = 1;
1802           *pszDestEnd = '\0';
1803         }
1804       }
1805       if(dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION)) {
1806         if(cchDest > 0) {
1807           pszDestEnd = pszDest;
1808           cchRemaining = cchDest;
1809           *pszDestEnd = '\0';
1810         }
1811       }
1812     }
1813   }
1814   if(SUCCEEDED(hr) || (hr==STRSAFE_E_INSUFFICIENT_BUFFER) || (hr==STRSAFE_E_END_OF_FILE)) {
1815     if(ppszDestEnd) *ppszDestEnd = pszDestEnd;
1816     if(pcchRemaining) *pcchRemaining = cchRemaining;
1817   }
1818   return hr;
1819 }
1820
1821 STRSAFE_INLINE_API StringGetsExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags) {
1822   HRESULT hr = S_OK;
1823   STRSAFE_LPWSTR pszDestEnd = pszDest;
1824   size_t cchRemaining = 0;
1825   if(dwFlags & (~STRSAFE_VALID_FLAGS)) {
1826     hr = STRSAFE_E_INVALID_PARAMETER;
1827   } else {
1828     if(dwFlags & STRSAFE_IGNORE_NULLS) {
1829       if(!pszDest) {
1830         if((cchDest!=0) || (cbDest!=0)) hr = STRSAFE_E_INVALID_PARAMETER;
1831       }
1832     }
1833     if(SUCCEEDED(hr)) {
1834       if(cchDest <= 1) {
1835         pszDestEnd = pszDest;
1836         cchRemaining = cchDest;
1837         if(cchDest==1) *pszDestEnd = L'\0';
1838         hr = STRSAFE_E_INSUFFICIENT_BUFFER;
1839       } else {
1840         pszDestEnd = pszDest;
1841         cchRemaining = cchDest;
1842         while(cchRemaining > 1) {
1843           wchar_t ch = getwc(stdin);
1844           if(ch==WEOF) {
1845             if(pszDestEnd==pszDest) hr = STRSAFE_E_END_OF_FILE;
1846             break;
1847           }
1848           if(ch==L'\n') break;
1849           *pszDestEnd = ch;
1850           pszDestEnd++;
1851           cchRemaining--;
1852         }
1853         if(cchRemaining > 0) {
1854           if(dwFlags & STRSAFE_FILL_BEHIND_NULL) {
1855             memset(pszDestEnd + 1,STRSAFE_GET_FILL_PATTERN(dwFlags),((cchRemaining - 1)*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t)));
1856           }
1857         }
1858         *pszDestEnd = L'\0';
1859       }
1860     }
1861   }
1862   if(FAILED(hr)) {
1863     if(pszDest) {
1864       if(dwFlags & STRSAFE_FILL_ON_FAILURE) {
1865         memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
1866         if(STRSAFE_GET_FILL_PATTERN(dwFlags)==0) {
1867           pszDestEnd = pszDest;
1868           cchRemaining = cchDest;
1869         } else if(cchDest > 0) {
1870           pszDestEnd = pszDest + cchDest - 1;
1871           cchRemaining = 1;
1872           *pszDestEnd = L'\0';
1873         }
1874       }
1875       if(dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION)) {
1876         if(cchDest > 0) {
1877           pszDestEnd = pszDest;
1878           cchRemaining = cchDest;
1879           *pszDestEnd = L'\0';
1880         }
1881       }
1882     }
1883   }
1884   if(SUCCEEDED(hr) || (hr==STRSAFE_E_INSUFFICIENT_BUFFER) || (hr==STRSAFE_E_END_OF_FILE)) {
1885     if(ppszDestEnd) *ppszDestEnd = pszDestEnd;
1886     if(pcchRemaining) *pcchRemaining = cchRemaining;
1887   }
1888   return hr;
1889 }
1890 #endif /* !__CRT__NO_INLINE */
1891
1892 #define StringCopyWorkerA StringCopyWorkerA_instead_use_StringCchCopyA_or_StringCchCopyExA;
1893 #define StringCopyWorkerW StringCopyWorkerW_instead_use_StringCchCopyW_or_StringCchCopyExW;
1894 #define StringCopyExWorkerA StringCopyExWorkerA_instead_use_StringCchCopyA_or_StringCchCopyExA;
1895 #define StringCopyExWorkerW StringCopyExWorkerW_instead_use_StringCchCopyW_or_StringCchCopyExW;
1896 #define StringCatWorkerA StringCatWorkerA_instead_use_StringCchCatA_or_StringCchCatExA;
1897 #define StringCatWorkerW StringCatWorkerW_instead_use_StringCchCatW_or_StringCchCatExW;
1898 #define StringCatExWorkerA StringCatExWorkerA_instead_use_StringCchCatA_or_StringCchCatExA;
1899 #define StringCatExWorkerW StringCatExWorkerW_instead_use_StringCchCatW_or_StringCchCatExW;
1900 #define StringCatNWorkerA StringCatNWorkerA_instead_use_StringCchCatNA_or_StrincCbCatNA;
1901 #define StringCatNWorkerW StringCatNWorkerW_instead_use_StringCchCatNW_or_StringCbCatNW;
1902 #define StringCatNExWorkerA StringCatNExWorkerA_instead_use_StringCchCatNExA_or_StringCbCatNExA;
1903 #define StringCatNExWorkerW StringCatNExWorkerW_instead_use_StringCchCatNExW_or_StringCbCatNExW;
1904 #define StringVPrintfWorkerA StringVPrintfWorkerA_instead_use_StringCchVPrintfA_or_StringCchVPrintfExA;
1905 #define StringVPrintfWorkerW StringVPrintfWorkerW_instead_use_StringCchVPrintfW_or_StringCchVPrintfExW;
1906 #define StringVPrintfExWorkerA StringVPrintfExWorkerA_instead_use_StringCchVPrintfA_or_StringCchVPrintfExA;
1907 #define StringVPrintfExWorkerW StringVPrintfExWorkerW_instead_use_StringCchVPrintfW_or_StringCchVPrintfExW;
1908 #define StringLengthWorkerA StringLengthWorkerA_instead_use_StringCchLengthA_or_StringCbLengthA;
1909 #define StringLengthWorkerW StringLengthWorkerW_instead_use_StringCchLengthW_or_StringCbLengthW;
1910 #define StringGetsExWorkerA StringGetsExWorkerA_instead_use_StringCchGetsA_or_StringCbGetsA
1911 #define StringGetsExWorkerW StringGetsExWorkerW_instead_use_StringCchGetsW_or_StringCbGetsW
1912
1913 /* Some Wine modules include us, don't specify STRSAFE_NO_DEPRECATE, and use deprecated functions */
1914 #ifndef STRSAFE_NO_DEPRECATE
1915 #define STRSAFE_NO_DEPRECATE
1916 #endif
1917
1918 #ifndef STRSAFE_NO_DEPRECATE
1919
1920 #undef strcpy
1921 #define strcpy strcpy_instead_use_StringCbCopyA_or_StringCchCopyA;
1922
1923 #undef wcscpy
1924 #define wcscpy wcscpy_instead_use_StringCbCopyW_or_StringCchCopyW;
1925
1926 #undef strcat
1927 #define strcat strcat_instead_use_StringCbCatA_or_StringCchCatA;
1928
1929 #undef wcscat
1930 #define wcscat wcscat_instead_use_StringCbCatW_or_StringCchCatW;
1931
1932 #undef sprintf
1933 #define sprintf sprintf_instead_use_StringCbPrintfA_or_StringCchPrintfA;
1934
1935 #undef swprintf
1936 #define swprintf swprintf_instead_use_StringCbPrintfW_or_StringCchPrintfW;
1937
1938 #undef vsprintf
1939 #define vsprintf vsprintf_instead_use_StringCbVPrintfA_or_StringCchVPrintfA;
1940
1941 #undef vswprintf
1942 #define vswprintf vswprintf_instead_use_StringCbVPrintfW_or_StringCchVPrintfW;
1943
1944 #undef _snprintf
1945 #define _snprintf _snprintf_instead_use_StringCbPrintfA_or_StringCchPrintfA;
1946
1947 #undef _snwprintf
1948 #define _snwprintf _snwprintf_instead_use_StringCbPrintfW_or_StringCchPrintfW;
1949
1950 #undef _vsnprintf
1951 #define _vsnprintf _vsnprintf_instead_use_StringCbVPrintfA_or_StringCchVPrintfA;
1952
1953 #undef _vsnwprintf
1954 #define _vsnwprintf _vsnwprintf_instead_use_StringCbVPrintfW_or_StringCchVPrintfW;
1955
1956 #undef strcpyA
1957 #define strcpyA strcpyA_instead_use_StringCbCopyA_or_StringCchCopyA;
1958
1959 #undef strcpyW
1960 #define strcpyW strcpyW_instead_use_StringCbCopyW_or_StringCchCopyW;
1961
1962 #undef lstrcpy
1963 #define lstrcpy lstrcpy_instead_use_StringCbCopy_or_StringCchCopy;
1964
1965 #undef lstrcpyA
1966 #define lstrcpyA lstrcpyA_instead_use_StringCbCopyA_or_StringCchCopyA;
1967
1968 #undef lstrcpyW
1969 #define lstrcpyW lstrcpyW_instead_use_StringCbCopyW_or_StringCchCopyW;
1970
1971 #undef StrCpy
1972 #define StrCpy StrCpy_instead_use_StringCbCopy_or_StringCchCopy;
1973
1974 #undef StrCpyA
1975 #define StrCpyA StrCpyA_instead_use_StringCbCopyA_or_StringCchCopyA;
1976
1977 #undef StrCpyW
1978 #define StrCpyW StrCpyW_instead_use_StringCbCopyW_or_StringCchCopyW;
1979
1980 #undef _tcscpy
1981 #define _tcscpy _tcscpy_instead_use_StringCbCopy_or_StringCchCopy;
1982
1983 #undef _ftcscpy
1984 #define _ftcscpy _ftcscpy_instead_use_StringCbCopy_or_StringCchCopy;
1985
1986 #undef lstrcat
1987 #define lstrcat lstrcat_instead_use_StringCbCat_or_StringCchCat;
1988
1989 #undef lstrcatA
1990 #define lstrcatA lstrcatA_instead_use_StringCbCatA_or_StringCchCatA;
1991
1992 #undef lstrcatW
1993 #define lstrcatW lstrcatW_instead_use_StringCbCatW_or_StringCchCatW;
1994
1995 #undef StrCat
1996 #define StrCat StrCat_instead_use_StringCbCat_or_StringCchCat;
1997
1998 #undef StrCatA
1999 #define StrCatA StrCatA_instead_use_StringCbCatA_or_StringCchCatA;
2000
2001 #undef StrCatW
2002 #define StrCatW StrCatW_instead_use_StringCbCatW_or_StringCchCatW;
2003
2004 #undef StrNCat
2005 #define StrNCat StrNCat_instead_use_StringCbCatN_or_StringCchCatN;
2006
2007 #undef StrNCatA
2008 #define StrNCatA StrNCatA_instead_use_StringCbCatNA_or_StringCchCatNA;
2009
2010 #undef StrNCatW
2011 #define StrNCatW StrNCatW_instead_use_StringCbCatNW_or_StringCchCatNW;
2012
2013 #undef StrCatN
2014 #define StrCatN StrCatN_instead_use_StringCbCatN_or_StringCchCatN;
2015
2016 #undef StrCatNA
2017 #define StrCatNA StrCatNA_instead_use_StringCbCatNA_or_StringCchCatNA;
2018
2019 #undef StrCatNW
2020 #define StrCatNW StrCatNW_instead_use_StringCbCatNW_or_StringCchCatNW;
2021
2022 #undef _tcscat
2023 #define _tcscat _tcscat_instead_use_StringCbCat_or_StringCchCat;
2024
2025 #undef _ftcscat
2026 #define _ftcscat _ftcscat_instead_use_StringCbCat_or_StringCchCat;
2027
2028 #undef wsprintf
2029 #define wsprintf wsprintf_instead_use_StringCbPrintf_or_StringCchPrintf;
2030
2031 #undef wsprintfA
2032 #define wsprintfA wsprintfA_instead_use_StringCbPrintfA_or_StringCchPrintfA;
2033
2034 #undef wsprintfW
2035 #define wsprintfW wsprintfW_instead_use_StringCbPrintfW_or_StringCchPrintfW;
2036
2037 #undef wvsprintf
2038 #define wvsprintf wvsprintf_instead_use_StringCbVPrintf_or_StringCchVPrintf;
2039
2040 #undef wvsprintfA
2041 #define wvsprintfA wvsprintfA_instead_use_StringCbVPrintfA_or_StringCchVPrintfA;
2042
2043 #undef wvsprintfW
2044 #define wvsprintfW wvsprintfW_instead_use_StringCbVPrintfW_or_StringCchVPrintfW;
2045
2046 #undef _vstprintf
2047 #define _vstprintf _vstprintf_instead_use_StringCbVPrintf_or_StringCchVPrintf;
2048
2049 #undef _vsntprintf
2050 #define _vsntprintf _vsntprintf_instead_use_StringCbVPrintf_or_StringCchVPrintf;
2051
2052 #undef _stprintf
2053 #define _stprintf _stprintf_instead_use_StringCbPrintf_or_StringCchPrintf;
2054
2055 #undef _sntprintf
2056 #define _sntprintf _sntprintf_instead_use_StringCbPrintf_or_StringCchPrintf;
2057
2058 #undef _getts
2059 #define _getts _getts_instead_use_StringCbGets_or_StringCchGets;
2060
2061 #undef gets
2062 #define gets _gets_instead_use_StringCbGetsA_or_StringCchGetsA;
2063
2064 #undef _getws
2065 #define _getws _getws_instead_use_StringCbGetsW_or_StringCchGetsW;
2066 #endif
2067
2068 #ifdef __clang__
2069 #pragma clang diagnostic pop
2070 #endif
2071
2072 #endif /* _STRSAFE_H_INCLUDED_ */