开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > GDI/图象编程 > 查看源码
atlchecked.h
资源名称：CreatBMP.rar　[点击查看]
上传用户：hfwmdy
上传日期：2016-01-14
资源大小：83k
文件大小：17k
源码类别：

GDI/图象编程

开发平台：

Visual C++

atlchecked.h：源码内容
  1. // This is a part of the Active Template Library.
  2. // Copyright (C) Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Active Template Library Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Active Template Library product.
  11. #ifndef __ATLCHECKED_H__
  12. #define __ATLCHECKED_H__
  14. #pragma once
  16. #include <atldef.h>
  17. #include <atlexcept.h>
  18. #include <malloc.h>
  19. #include <string.h>
  20. #include <mbstring.h>
  21. #include <wchar.h>
  22. #include <tchar.h>
  23. #include <stdlib.h>
  26. #pragma pack(push,_ATL_PACKING)
  27. namespace ATL
  28. {
  30. inline errno_t AtlCrtErrorCheck(errno_t nError)
  31. {
  32. switch(nError)
  33. {
  34. case ENOMEM:
  35. AtlThrow(E_OUTOFMEMORY);
  36. break;
  37. case EINVAL:
  38. case ERANGE:
  39. AtlThrow(E_INVALIDARG);
  40. break;
  41. case 0:
  42. case STRUNCATE:
  43. break;
  44. default:
  45. AtlThrow(E_FAIL);
  46. break;
  47. }
  48. return nError;
  49. }
  51. /////////////////////////////////////////////////////////////////////////////
  52. // Secure (Checked) CRT functions
  54. namespace Checked
  55. {
  57. #if _SECURE_ATL
  59. #ifdef _AFX
  60. #define ATLMFC_CRT_ERRORCHECK(expr) AFX_CRT_ERRORCHECK(expr)
  61. #else
  62. #define ATLMFC_CRT_ERRORCHECK(expr) ATL_CRT_ERRORCHECK(expr)
  63. #endif
  65. inline void __cdecl memcpy_s(__out_bcount_part(_S1max,_N)  void *_S1, __in size_t _S1max, __in_bcount(_N) const void *_S2, __in size_t _N)
  66. {
  67. ATLMFC_CRT_ERRORCHECK(::memcpy_s(_S1, _S1max, _S2, _N));
  68. }
  70. inline void __cdecl wmemcpy_s(__out_ecount_part(_N1,_N) wchar_t *_S1, __in size_t _N1, __in_ecount(_N) const wchar_t *_S2, __in size_t _N)
  71. {
  72. ATLMFC_CRT_ERRORCHECK(::wmemcpy_s(_S1, _N1, _S2, _N));
  73. }
  75. inline void __cdecl memmove_s(__out_bcount_part(_S1max,_N) void *_S1, __in size_t _S1max, __in_bcount(_N) const void *_S2, size_t _N)
  76. {
  77. ATLMFC_CRT_ERRORCHECK(::memmove_s(_S1, _S1max, _S2, _N));
  78. }
  80. inline void __cdecl strcpy_s(__out_ecount(_S1max) char *_S1, __in size_t _S1max, __in_z const char *_S2)
  81. {
  82. ATLMFC_CRT_ERRORCHECK(::strcpy_s(_S1, _S1max, _S2));
  83. }
  85. inline void __cdecl wcscpy_s(__out_ecount(_S1max) wchar_t *_S1, __in size_t _S1max, __in_z const wchar_t *_S2)
  86. {
  87. ATLMFC_CRT_ERRORCHECK(::wcscpy_s(_S1, _S1max, _S2));
  88. }
  90. inline void __cdecl tcscpy_s(__out_ecount(_SizeInChars) TCHAR * _Dst, __in size_t _SizeInChars, __in_z const TCHAR * _Src)
  91. {
  92. #ifndef _ATL_MIN_CRT
  93. ATLMFC_CRT_ERRORCHECK(::_tcscpy_s(_Dst, _SizeInChars, _Src));
  94. #else
  95. #ifdef UNICODE
  96. ATLMFC_CRT_ERRORCHECK(::wcscpy_s(_Dst, _SizeInChars, _Src));
  97. #else
  98. ATLMFC_CRT_ERRORCHECK(::strcpy_s(_Dst, _SizeInChars, _Src));
  99. #endif
  100. #endif
  101. }
  103. inline errno_t __cdecl strncpy_s(__out_ecount(_SizeInChars) char *_Dest, __in size_t _SizeInChars, __in_z const char *_Source, __in size_t _Count)
  104. {
  105. return ATLMFC_CRT_ERRORCHECK(::strncpy_s(_Dest, _SizeInChars, _Source,_Count));
  106. }
  108. inline errno_t __cdecl wcsncpy_s(__out_ecount(_SizeInChars) wchar_t *_Dest, __in size_t _SizeInChars, __in_z const wchar_t *_Source, __in size_t _Count)
  109. {
  110. return ATLMFC_CRT_ERRORCHECK(::wcsncpy_s(_Dest, _SizeInChars, _Source,_Count));
  111. }
  113. inline errno_t __cdecl tcsncpy_s(__out_ecount(_SizeInChars) TCHAR *_Dest, __in size_t _SizeInChars, __in_z const TCHAR *_Source, __in size_t _Count)
  114. {
  115. #ifndef _ATL_MIN_CRT
  116. return ATLMFC_CRT_ERRORCHECK(::_tcsncpy_s(_Dest, _SizeInChars, _Source,_Count));
  117. #else
  118. #ifdef UNICODE
  119. return ATLMFC_CRT_ERRORCHECK(::wcsncpy_s(_Dest, _SizeInChars, _Source,_Count));
  120. #else
  121. return ATLMFC_CRT_ERRORCHECK(::strncpy_s(_Dest, _SizeInChars, _Source,_Count));
  122. #endif
  123. #endif
  124. }
  126. inline void __cdecl strcat_s(__inout_ecount_z(_SizeInChars) char * _Dst, __in size_t _SizeInChars, __in_z const char * _Src)
  127. {
  128. ATLMFC_CRT_ERRORCHECK(::strcat_s(_Dst, _SizeInChars, _Src));
  129. }
  131. inline void __cdecl wcscat_s(__inout_ecount_z(_SizeInChars) wchar_t * _Dst, __in size_t _SizeInChars, __in_z const wchar_t * _Src)
  132. {
  133. ATLMFC_CRT_ERRORCHECK(::wcscat_s(_Dst, _SizeInChars, _Src));
  134. }
  136. inline void __cdecl tcscat_s(__inout_ecount_z(_SizeInChars) TCHAR * _Dst, __in size_t _SizeInChars, __in_z const TCHAR * _Src)
  137. {
  138. #ifndef _ATL_MIN_CRT
  139. ATLMFC_CRT_ERRORCHECK(::_tcscat_s(_Dst, _SizeInChars, _Src));
  140. #else
  141. #ifdef UNICODE
  142. ATLMFC_CRT_ERRORCHECK(::wcscat_s(_Dst, _SizeInChars, _Src));
  143. #else
  144. ATLMFC_CRT_ERRORCHECK(::strcat_s(_Dst, _SizeInChars, _Src));
  145. #endif
  146. #endif
  147. }
  149. inline void __cdecl strlwr_s(__inout_ecount_z(_SizeInChars) char * _Str, __in size_t _SizeInChars)
  150. {
  151. ATLMFC_CRT_ERRORCHECK(::_strlwr_s(_Str, _SizeInChars));
  152. }
  154. inline void __cdecl wcslwr_s(__inout_ecount_z(_SizeInChars) wchar_t * _Str, __in size_t _SizeInChars)
  155. {
  156. ATLMFC_CRT_ERRORCHECK(::_wcslwr_s(_Str, _SizeInChars));
  157. }
  159. inline void __cdecl mbslwr_s(__inout_bcount_z(_SizeInChars) unsigned char * _Str, __in size_t _SizeInChars)
  160. {
  161. ATLMFC_CRT_ERRORCHECK(::_mbslwr_s(_Str, _SizeInChars));
  162. }
  164. inline void __cdecl tcslwr_s(__inout_ecount_z(_SizeInChars) TCHAR * _Str, __in size_t _SizeInChars)
  165. {
  166. #ifndef _ATL_MIN_CRT
  167. ATLMFC_CRT_ERRORCHECK(::_tcslwr_s(_Str, _SizeInChars));
  168. #else
  169. #ifdef UNICODE
  170. ATLMFC_CRT_ERRORCHECK(::_wcslwr_s(_Str, _SizeInChars));
  171. #else
  172. ATLMFC_CRT_ERRORCHECK(::_strlwr_s(_Str, _SizeInChars));
  173. #endif
  174. #endif
  175. }
  177. inline void __cdecl strupr_s(__inout_ecount_z(_SizeInChars) char * _Str, __in size_t _SizeInChars)
  178. {
  179. ATLMFC_CRT_ERRORCHECK(::_strupr_s(_Str, _SizeInChars));
  180. }
  182. inline void __cdecl wcsupr_s(__inout_ecount_z(_SizeInChars) wchar_t * _Str, __in size_t _SizeInChars)
  183. {
  184. ATLMFC_CRT_ERRORCHECK(::_wcsupr_s(_Str, _SizeInChars));
  185. }
  187. inline void __cdecl mbsupr_s(__inout_bcount_z(_SizeInChars) unsigned char * _Str, __in size_t _SizeInChars)
  188. {
  189. ATLMFC_CRT_ERRORCHECK(::_mbsupr_s(_Str, _SizeInChars));
  190. }
  192. inline void __cdecl tcsupr_s(__inout_ecount_z(_SizeInChars) TCHAR * _Str, __in size_t _SizeInChars)
  193. {
  194. ATLMFC_CRT_ERRORCHECK(::_tcsupr_s(_Str, _SizeInChars));
  195. }
  197. inline void __cdecl itoa_s(__in int _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
  198. {
  199. ATLMFC_CRT_ERRORCHECK(::_itoa_s(_Val, _Buf, _SizeInChars, _Radix));
  200. }
  202. inline void __cdecl itot_s(__in int _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
  203. {
  204. ATLMFC_CRT_ERRORCHECK(::_itot_s(_Val, _Buf, _SizeInChars, _Radix));
  205. }
  207. inline void __cdecl ltoa_s(__in long _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
  208. {
  209. ATLMFC_CRT_ERRORCHECK(::_ltoa_s(_Val, _Buf, _SizeInChars, _Radix));
  210. }
  212. inline void __cdecl ltot_s(__in long _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
  213. {
  214. ATLMFC_CRT_ERRORCHECK(::_ltot_s(_Val, _Buf, _SizeInChars, _Radix));
  215. }
  217. inline void __cdecl ultoa_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
  218. {
  219. ATLMFC_CRT_ERRORCHECK(::_ultoa_s(_Val, _Buf, _SizeInChars, _Radix));
  220. }
  222. inline void __cdecl ultow_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
  223. {
  224. ATLMFC_CRT_ERRORCHECK(::_ultow_s(_Val, _Buf, _SizeInChars, _Radix));
  225. }
  227. inline void __cdecl ultot_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
  228. {
  229. ATLMFC_CRT_ERRORCHECK(::_ultot_s(_Val, _Buf, _SizeInChars, _Radix));
  230. }
  232. inline void __cdecl i64toa_s(__in __int64 _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
  233. {
  234. ATLMFC_CRT_ERRORCHECK(::_i64toa_s(_Val, _Buf, _SizeInChars, _Radix));
  235. }
  237. inline void __cdecl i64tow_s(__in __int64 _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
  238. {
  239. ATLMFC_CRT_ERRORCHECK(::_i64tow_s(_Val, _Buf, _SizeInChars, _Radix));
  240. }
  242. inline void __cdecl ui64toa_s(__in unsigned __int64 _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
  243. {
  244. ATLMFC_CRT_ERRORCHECK(::_ui64toa_s(_Val, _Buf, _SizeInChars, _Radix));
  245. }
  247. inline void __cdecl ui64tow_s(__in unsigned __int64 _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
  248. {
  249. ATLMFC_CRT_ERRORCHECK(::_ui64tow_s(_Val, _Buf, _SizeInChars, _Radix));
  250. }
  252. inline void __cdecl gcvt_s(__out_ecount_z(_SizeInChars) char *_Buffer, __in size_t _SizeInChars, __in double _Value, __in int _Ndec)
  253. {
  254. ATLMFC_CRT_ERRORCHECK(::_gcvt_s(_Buffer, _SizeInChars, _Value, _Ndec));
  255. }
  257. inline void __cdecl tsplitpath_s(__in_z const TCHAR *_Path, __out_ecount_z_opt(_Drive_len) TCHAR *_Drive, __in size_t _Drive_len, 
  258. __out_ecount_z_opt(_Dir_len) TCHAR *_Dir, __in size_t _Dir_len, 
  259. __out_ecount_z_opt(_Fname_len) TCHAR *_Fname, __in size_t _Fname_len, 
  260. __out_ecount_z_opt(_Ext_len) TCHAR *_Ext, __in size_t _Ext_len)
  261. {
  262. ATLMFC_CRT_ERRORCHECK(::_tsplitpath_s(_Path, _Drive, _Drive_len, _Dir, _Dir_len, _Fname, _Fname_len, _Ext, _Ext_len));
  263. }
  265. inline void __cdecl tmakepath_s(__out_ecount_z(_SizeInChars) TCHAR *_Path, __in size_t _SizeInChars, __in_z const TCHAR *_Drive, 
  266. __in_z const TCHAR *_Dir, __in_z const TCHAR *_Fname, __in_z const TCHAR *_Ext)
  267. {
  268. ATLMFC_CRT_ERRORCHECK(::_tmakepath_s(_Path, _SizeInChars, _Drive, _Dir, _Fname, _Ext));
  269. }
  271. inline size_t __cdecl strnlen(__in_ecount(_Maxsize) const char *_Str, __in size_t _Maxsize)
  272. {
  273. return ::strnlen(_Str, _Maxsize);
  274. }
  276. inline size_t __cdecl wcsnlen(__in_ecount(_Maxsize) const wchar_t *_Wcs, __in size_t _Maxsize)
  277. {
  278. return ::wcsnlen(_Wcs, _Maxsize);
  279. }
  281. inline size_t __cdecl tcsnlen(__in_ecount(_Maxsize) const TCHAR *_Str, __in size_t _Maxsize)
  282. {
  283. return ::_tcsnlen(_Str, _Maxsize);
  284. }
  286. inline int get_errno()
  287. {
  288. int nErrNo;
  289. ATLMFC_CRT_ERRORCHECK(::_get_errno(&nErrNo));
  290. return nErrNo;
  291. }
  293. inline void set_errno(__in int _Value)
  294. {
  295. ATLMFC_CRT_ERRORCHECK(::_set_errno(_Value));
  296. }
  298. #else // !_SECURE_ATL
  300. #define ATLMFC_CRT_ERRORCHECK(expr) do { expr; } while (0)
  302. inline void __cdecl memcpy_s(__out_bcount(_S1max) void *_S1, __in size_t _S1max, __in_bcount(_N) const void *_S2, size_t _N)
  303. {
  304. (_S1max);
  305. memcpy(_S1, _S2, _N);
  306. }
  308. inline void __cdecl wmemcpy_s(__out_ecount(_N1) wchar_t *_S1, __in size_t _N1, __in_ecount(_N) const wchar_t *_S2, __in size_t _N)
  309. {
  310. (_N1);
  311. ::wmemcpy(_S1, _S2, _N);
  312. }
  314. inline void __cdecl memmove_s(__out_bcount(_S1max) void *_S1, __in size_t _S1max, __in_bcount(_N) const void *_S2, __in size_t _N)
  315. {
  316. (_S1max);
  317. memmove(_S1, _S2, _N);
  318. }
  320. inline void __cdecl strcpy_s(__out_ecount_z(_S1max) char *_S1, __in size_t _S1max, __in_z const char *_S2)
  321. {
  322. (_S1max);
  323. ::strcpy(_S1, _S2);
  324. }
  326. inline void __cdecl wcscpy_s(__out_ecount_z(_S1max) wchar_t *_S1, __in size_t _S1max, __in_z const wchar_t *_S2)
  327. {
  328. (_S1max);
  329. ::wcscpy(_S1, _S2);
  330. }
  332. inline void __cdecl tcscpy_s(__out_ecount_z(_SizeInChars) TCHAR * _Dst, __in size_t _SizeInChars, __in_z const TCHAR * _Src)
  333. {
  334. (_SizeInChars);
  335. #ifndef _ATL_MIN_CRT
  336. ::_tcscpy(_Dst, _Src);
  337. #else
  338. #ifdef UNICODE
  339. ::wcscpy(_Dst, _Src);
  340. #else
  341. ::strcpy(_Dst, _Src);
  342. #endif
  343. #endif
  344. }
  346. /* ensure that strncpy_s null-terminate the dest string */
  347. inline errno_t __cdecl strncpy_s(__out_ecount_z(_SizeInChars) char *_Dest, __in size_t _SizeInChars, __in_z const char *_Source,__in size_t _Count)
  348. {
  349. if (_Count == _TRUNCATE)
  350. {
  351. _Count = _SizeInChars - 1;
  352. }
  353. while (_Count > 0 && *_Source != 0)
  354. {
  355. *_Dest++ = *_Source++;
  356. --_Count;
  357. }
  358. *_Dest = 0;
  360. return (*_Source!=0) ? STRUNCATE : 0;
  361. }
  363. inline errno_t __cdecl wcsncpy_s(__out_ecount_z(_SizeInChars) wchar_t *_Dest, __in size_t _SizeInChars, __in_z const wchar_t *_Source, __in size_t _Count)
  364. {
  365. if (_Count == _TRUNCATE)
  366. {
  367. _Count = _SizeInChars - 1;
  368. }
  369. while (_Count > 0 && *_Source != 0)
  370. {
  371. *_Dest++ = *_Source++;
  372. --_Count;
  373. }
  374. *_Dest = 0;
  376. return (*_Source!=0) ? STRUNCATE : 0;
  377. }
  379. inline errno_t __cdecl tcsncpy_s(__out_ecount_z(_SizeInChars) TCHAR *_Dest, __in size_t _SizeInChars, __in_z const TCHAR *_Source,__in size_t _Count)
  380. {
  381. if (_Count == _TRUNCATE)
  382. {
  383. if(_SizeInChars>0)
  384. {
  385. _Count = _SizeInChars - 1;
  386. }
  387. else
  388. {
  389. _Count =0;
  390. }
  391. }
  393. #ifndef _ATL_MIN_CRT
  394. #pragma warning(push)
  395. #pragma warning(disable: 6535)
  396. ::_tcsncpy(_Dest,_Source,_Count);
  397. #pragma warning(pop)
  398. if(_SizeInChars>0)
  399. {
  400. _Dest[_SizeInChars-1] = 0;
  401. }
  402. #else
  403. while (_Count > 0 && *_Source != 0)
  404. {
  405. *_Dest++ = *_Source++;
  406. --_Count;
  407. }
  408. *_Dest = 0;
  409. #endif
  411. return (*_Source!=0) ? STRUNCATE : 0;
  412. }
  414. inline void __cdecl strcat_s(__inout_ecount_z(_SizeInChars) char * _Dst, __in size_t _SizeInChars, __in_z const char * _Src)
  415. {
  416. (_SizeInChars);
  417. ::strcat(_Dst, _Src);
  418. }
  420. inline void __cdecl wcscat_s(__inout_ecount_z(_SizeInChars) wchar_t * _Dst, __in size_t _SizeInChars, __in_z const wchar_t * _Src)
  421. {
  422. (_SizeInChars);
  423. ::wcscat(_Dst, _Src);
  424. }
  426. inline void __cdecl tcscat_s(__inout_ecount_z(_SizeInChars) TCHAR * _Dst, __in size_t _SizeInChars, __in_z const TCHAR * _Src)
  427. {
  428. (_SizeInChars);
  429. #ifndef _ATL_MIN_CRT
  430. ::_tcscat(_Dst, _Src);
  431. #else
  432. #ifdef UNICODE
  433. ::wcscat(_Dst, _Src);
  434. #else
  435. ::strcat(_Dst, _Src);
  436. #endif
  437. #endif
  438. }
  440. inline void __cdecl strlwr_s(__inout_ecount_z(_SizeInChars) char * _Str, size_t _SizeInChars)
  441. {
  442. (_SizeInChars);
  443. ::_strlwr(_Str);
  444. }
  446. inline void __cdecl wcslwr_s(__inout_ecount_z(_SizeInChars) wchar_t * _Str, size_t _SizeInChars)
  447. {
  448. (_SizeInChars);
  449. ::_wcslwr(_Str);
  450. }
  452. inline void __cdecl mbslwr_s(__inout_bcount_z(_SizeInChars) unsigned char * _Str, size_t _SizeInChars)
  453. {
  454. (_SizeInChars);
  455. ::_mbslwr(_Str);
  456. }
  458. inline void __cdecl tcslwr_s(__inout_ecount_z(_SizeInChars) TCHAR * _Str, size_t _SizeInChars)
  459. {
  460. (_SizeInChars);
  461. #ifndef _ATL_MIN_CRT
  462. ::_tcslwr(_Str);
  463. #else
  464. #ifdef UNICODE
  465. ::_wcslwr(_Str);
  466. #else
  467. ::_strlwr(_Str);
  468. #endif
  469. #endif
  470. }
  472. inline void __cdecl itoa_s(__in int _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
  473. {
  474. (_SizeInChars);
  475. ::_itoa_s(_Val, _Buf, _SizeInChars, _Radix);
  476. }
  478. inline void __cdecl itot_s(__in int _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
  479. {
  480. (_SizeInChars);
  481. ::_itot(_Val, _Buf, _Radix);
  482. }
  484. inline void __cdecl ltoa_s(__in long _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
  485. {
  486. (_SizeInChars);
  487. ::_ltoa(_Val, _Buf, _Radix);
  488. }
  490. inline void __cdecl ltot_s(__in long _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
  491. {
  492. (_SizeInChars);
  493. ::_ltot(_Val, _Buf, _Radix);
  494. }
  496. inline void __cdecl ultoa_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
  497. {
  498. (_SizeInChars);
  499. ::_ultoa(_Val, _Buf, _Radix);
  500. }
  502. inline void __cdecl ultow_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
  503. {
  504. (_SizeInChars);
  505. ::_ultow(_Val, _Buf, _Radix);
  506. }
  508. inline void __cdecl ultot_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
  509. {
  510. (_SizeInChars);
  511. ::_ultot(_Val, _Buf, _Radix);
  512. }
  514. inline void __cdecl i64toa_s(__in __int64 _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
  515. {
  516. (_SizeInChars);
  517. ::_i64toa(_Val, _Buf, _Radix);
  518. }
  520. inline void __cdecl i64tow_s(__in __int64 _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
  521. {
  522. (_SizeInChars);
  523. ::_i64tow(_Val, _Buf, _Radix);
  524. }
  526. inline void __cdecl ui64toa_s(__in unsigned __int64 _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
  527. {
  528. (_SizeInChars);
  529. ::_ui64toa(_Val, _Buf, _Radix);
  530. }
  532. inline void __cdecl ui64tow_s(__in unsigned __int64 _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
  533. {
  534. (_SizeInChars);
  535. ::_ui64tow(_Val, _Buf, _Radix);
  536. }
  538. inline void __cdecl gcvt_s(__out_ecount_z(_SizeInChars) char *_Buffer, __in size_t _SizeInChars, __in double _Value, __in int _Ndec)
  539. {
  540. (_SizeInChars);
  541. ::_gcvt(_Value, _Ndec, _Buffer);
  542. }
  544. inline void __cdecl tsplitpath_s(__in_z const TCHAR *_Path, __out_ecount_z_opt(_Drive_len) TCHAR *_Drive, __in size_t _Drive_len, 
  545. __out_ecount_z_opt(_Dir_len) TCHAR *_Dir, __in size_t _Dir_len, 
  546. __out_ecount_z_opt(_Fname_ext) TCHAR *_Fname, __in size_t _Fname_len, 
  547. __out_ecount_z_opt(_Ext_len) TCHAR *_Ext, __in size_t _Ext_len)
  548. {
  549. (_Drive_len, _Dir_len, _Fname_len, _Ext_len);
  550. ::_tsplitpath(_Path, _Drive, _Dir, _Fname, _Ext);
  551. }
  553. inline void __cdecl tmakepath_s(__out_ecount_z(_SizeInChars) TCHAR *_Path, __in size_t _SizeInChars, __in_z const TCHAR *_Drive, 
  554. __in_z const TCHAR *_Dir, __in_z const TCHAR *_Fname, __in_z const TCHAR *_Ext)
  555. {
  556. (_SizeInChars);
  557. ::_tmakepath(_Path, _Drive, _Dir, _Fname, _Ext);
  558. }
  560. inline size_t __cdecl strnlen(__in_ecount(_Maxsize) const char *_Str, __in size_t _Maxsize)
  561. {
  562. (_Maxsize);
  563. return ::strlen(_Str);
  564. }
  566. inline size_t __cdecl wcsnlen(__in_ecount(_Maxsize) const wchar_t *_Wcs, __in size_t _Maxsize)
  567. {
  568. (_Maxsize);
  569. return ::wcslen(_Wcs);
  570. }
  572. inline size_t __cdecl tcsnlen(__in_ecount(_Maxsize) const TCHAR *_Str, __in size_t _Maxsize)
  573. {
  574. (_Maxsize);
  575. return ::_tcslen(_Str);
  576. }
  578. inline int get_errno()
  579. {
  580. return errno;
  581. }
  583. inline void set_errno(__in int _Value)
  584. {
  585. errno = _Value;
  586. }
  588. #endif // _SECURE_ATL
  590. } // namespace Checked
  592. } // namespace ATL
  593. #pragma pack(pop)
  595. #endif // __ATLCHECKED_H__
  597. /////////////////////////////////////////////////////////////////////////////