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