home *** CD-ROM | disk | FTP | other *** search
/ PC Format (South-Africa) 2001 June / PCFJune.iso / Xenon / C++ / FreeCommandLineTools.exe / Include / stdlib.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-31  |  20.9 KB  |  659 lines
  1. /*  stdlib.h
  2.  
  3.     Definitions for common types, variables, and functions.
  4.  
  5. */
  6.  
  7. /*
  8.  *      C/C++ Run Time Library - Version 10.0
  9.  *
  10.  *      Copyright (c) 1987, 2000 by Inprise Corporation
  11.  *      All Rights Reserved.
  12.  *
  13.  */
  14.  
  15. /* $Revision:   9.19  $ */
  16.  
  17. #ifndef __STDLIB_H
  18. #define __STDLIB_H
  19. #define _INC_STDLIB  /* MSC Guard name */
  20.  
  21. #ifndef ___STDDEF_H
  22. #include <_stddef.h>
  23. #endif
  24.  
  25. #ifndef __SEARCH_H
  26. #include <search.h>  /* Factored out all the search functions to search.h */
  27. #endif
  28.  
  29. #if !defined(RC_INVOKED)
  30. #if defined(__STDC__)
  31. #pragma warn -nak
  32. #endif
  33. #endif  /* !RC_INVOKED */
  34.  
  35. #ifdef __cplusplus
  36. extern "C"{
  37. #endif
  38.  
  39. /* Intrinsics must be prototyped outside of any namespace, so we list them here
  40.    before entering namespace std.
  41.  */
  42. int            _RTLENTRY __abs__(int);
  43. unsigned char  _RTLENTRY ___crotl__(unsigned char __value, int __count);
  44. unsigned char  _RTLENTRY ___crotr__(unsigned char __value, int __count);
  45. unsigned long  _RTLENTRY ___lrotl__(unsigned long __val, int __count);
  46. unsigned long  _RTLENTRY ___lrotr__(unsigned long __val, int __count);
  47. unsigned short _RTLENTRY ___rotl__ (unsigned short __value, int __count);
  48. unsigned short _RTLENTRY ___rotr__ (unsigned short __value, int __count);
  49.  
  50. #ifdef __cplusplus
  51. } // extern "C"
  52. #endif
  53.  
  54. #ifdef __cplusplus
  55. namespace std {
  56. #endif /* __cplusplus */
  57.  
  58. #if !defined(RC_INVOKED)
  59.  
  60. #pragma pack(push, 1)
  61.  
  62. #endif  /* !RC_INVOKED */
  63.  
  64. #ifndef _DIV_T
  65. #define _DIV_T
  66. typedef struct {
  67.         int     quot;
  68.         int     rem;
  69. } div_t;
  70. #endif
  71.  
  72. #ifndef _LDIV_T
  73. #define _LDIV_T
  74. typedef struct {
  75.         long    quot;
  76.         long    rem;
  77. } ldiv_t;
  78. #endif
  79.  
  80. #define MB_CUR_MAX __mb_cur_max
  81.  
  82. /* Maximum value returned by "rand" function
  83. */
  84. #define RAND_MAX  0x7FFFU
  85.  
  86. /* Maximum value returned by "_lrand" function (also used by random() macro)
  87. */
  88. #define LRAND_MAX 0x7FFFFFFFU
  89.  
  90. #define EXIT_SUCCESS 0
  91. #define EXIT_FAILURE 1
  92.  
  93. typedef void (_USERENTRY * atexit_t)(void);
  94.  
  95. /*
  96.   These 2 constants are defined in MS's stdlib.h.
  97. */
  98.  
  99. #define DOS_MODE    0  /* DOS 16-bit */
  100. #define OS2_MODE    1  /* OS/2 16-bit */
  101.  
  102.  
  103. #ifdef __cplusplus
  104. extern "C" {
  105. #endif
  106.  
  107. void        _RTLENTRY _EXPFUNC abort(void);
  108.  
  109. #if !defined(__ABS_DEFINED)
  110. #define __ABS_DEFINED
  111.  
  112.  
  113. #ifdef __cplusplus
  114. inline int _RTLENTRY  abs(int __x) { return __abs__(__x); }
  115. #else
  116. int         _RTLENTRY _EXPFUNC abs(int __x);
  117. #  define abs(__x)   __abs__(__x)
  118. #endif
  119.  
  120. #endif /* __ABS_DEFINED */
  121.  
  122.  
  123. int           _RTLENTRY _EXPFUNC atexit(void (_USERENTRY * __func)(void));
  124. double        _RTLENTRY _EXPFUNC atof(const char * __s);
  125. int           _RTLENTRY _EXPFUNC atoi(const char * __s);
  126. long          _RTLENTRY _EXPFUNC atol(const char * __s);
  127. void *        _RTLENTRY _EXPFUNC calloc(_SIZE_T __nitems, _SIZE_T __size);
  128. div_t         _RTLENTRY _EXPFUNC div(int __numer, int __denom);
  129. void          _RTLENTRY _EXPFUNC exit(int __status);
  130. void          _RTLENTRY _EXPFUNC free(void * __block);
  131. char *        _RTLENTRY _EXPFUNC getenv(const char * __name);
  132. long          _RTLENTRY _EXPFUNC labs(long __x);
  133. ldiv_t        _RTLENTRY _EXPFUNC ldiv(long __numer, long __denom);
  134. void *        _RTLENTRY _EXPFUNC malloc(_SIZE_T __size);
  135. int           _RTLENTRY _EXPFUNC mblen(const char * __s, _SIZE_T __n);
  136. _SIZE_T       _RTLENTRY _EXPFUNC mbstowcs(wchar_t *__pwcs, const char * __s,
  137.                                      _SIZE_T __n);
  138. int           _RTLENTRY _EXPFUNC mbtowc(wchar_t *__pwc, const char * __s, _SIZE_T __n);
  139. int           _RTLENTRY _EXPFUNC rand(void);
  140. void *        _RTLENTRY _EXPFUNC realloc(void * __block, _SIZE_T __size);
  141. void          _RTLENTRY _EXPFUNC srand(unsigned __seed);
  142. double        _RTLENTRY _EXPFUNC strtod(const char * __s, char * *__endptr);
  143. long          _RTLENTRY _EXPFUNC strtol(const char * __s, char * *__endptr,
  144.                                      int __radix);
  145. long double   _RTLENTRY _EXPFUNC _strtold(const char * __s, char * *__endptr);
  146. unsigned long _RTLENTRY _EXPFUNC strtoul(const char * __s, char * *__endptr,
  147.                                      int __radix);
  148. int           _RTLENTRY _EXPFUNC system(const char * __command);
  149.  
  150. _SIZE_T       _RTLENTRY _EXPFUNC wcstombs(char * __s, const wchar_t *__pwcs,_SIZE_T __n);
  151. int           _RTLENTRY _EXPFUNC wctomb(char * __s, wchar_t __wc);
  152. double        _RTLENTRY _EXPFUNC _wtof(const wchar_t * __s);
  153. int           _RTLENTRY _EXPFUNC _wtoi(const wchar_t * __s);
  154. long          _RTLENTRY _EXPFUNC _wtol(const wchar_t * __s);
  155. long double   _RTLENTRY _EXPFUNC _wtold(const wchar_t * __s);
  156. double        _RTLENTRY _EXPFUNC wcstod(const wchar_t * __s, wchar_t * *__endptr);
  157. long          _RTLENTRY _EXPFUNC wcstol(const wchar_t * __s, wchar_t * *__endptr, int __radix);
  158. long double   _RTLENTRY _EXPFUNC _wcstold(const wchar_t * __s, wchar_t * *__endptr);
  159. unsigned long _RTLENTRY _EXPFUNC wcstoul(const wchar_t * __s, wchar_t * *__endptr, int __radix);
  160. int           _RTLENTRY _EXPFUNC _wsystem(const wchar_t * __command);
  161. wchar_t *     _RTLENTRY _EXPFUNC _itow(int __value, wchar_t *__string, int __radix);
  162. wchar_t *     _RTLENTRY _EXPFUNC _ltow(long __value, wchar_t *__string, int __radix);
  163. wchar_t *     _RTLENTRY _EXPFUNC _ultow(unsigned long __value, wchar_t *__string, int __radix);
  164.  
  165. #if !defined(__STDC__)
  166. #if defined (_INTEGRAL_MAX_BITS) && (_INTEGRAL_MAX_BITS >= 64)
  167. __int64       _RTLENTRY _EXPFUNC _atoi64(const char * __s);
  168. char *        _RTLENTRY _EXPFUNC _i64toa(__int64 __value, char *__strP, int __radix);
  169. char *        _RTLENTRY _EXPFUNC _ui64toa(unsigned __int64 __value, char *__strP, int __radix);
  170. __int64       _RTLENTRY _EXPFUNC _wtoi64(const wchar_t * __s);
  171. wchar_t *     _RTLENTRY _EXPFUNC _i64tow(__int64 __value, wchar_t *__strP, int __radix);
  172. wchar_t *     _RTLENTRY _EXPFUNC _ui64tow(unsigned __int64 __value, wchar_t *__strP, int __radix);
  173. #endif
  174. char *        _RTLENTRY _EXPFUNC ltoa(long __value, char * __string, int __radix);
  175. char *        _RTLENTRY _EXPFUNC ecvt(double __value, int __ndig, int * __dec, int * __sign);
  176. char *        _RTLENTRY _EXPFUNC fcvt(double __value, int __ndig, int * __dec, int * __sign);
  177. char *        _RTLENTRY _EXPFUNC gcvt(double __value, int __ndec, char * __buf);
  178.  
  179. #endif /* __STDC__ */
  180.  
  181.  
  182. /* Variables */
  183.  
  184. #ifdef _MT
  185.  
  186. extern  int * _RTLENTRY _EXPFUNC __errno(void);
  187. extern  int * _RTLENTRY _EXPFUNC __doserrno(void);
  188. #define errno (*__errno())
  189. #define _doserrno (*__doserrno())
  190.  
  191. #else   /* MT */
  192.  
  193. extern  int   _RTLENTRY _EXPDATA errno;
  194. extern  int   _RTLENTRY _EXPDATA _doserrno;
  195.  
  196. #endif  /* MT */
  197.  
  198. extern  int   _RTLENTRY _EXPDATA __mb_cur_max;
  199.  
  200. #if !defined(__STDC__)
  201.  
  202. /* Values for _osmode */
  203.  
  204. #define _WIN_MODE    2  /* Windows 16- or 32-bit */
  205. #define _OS2_20_MODE 3  /* OS/2 32-bit */
  206. #define _DOSX32_MODE 4  /* DOS 32-bit */
  207.  
  208. #define environ  _environ
  209.  
  210. /* MSC compatible routines: */
  211.  
  212. void _RTLENTRY _EXPFUNC _seterrormode(int __mode);
  213.  
  214. #endif /* __STDC__ */
  215.  
  216. extern char **       _RTLENTRY _EXPDATA _environ;
  217. extern wchar_t **    _RTLENTRY _EXPDATA _wenviron;
  218. extern int           _RTLENTRY _EXPDATA _fileinfo;
  219. extern int           _RTLENTRY          _fmode;
  220. extern unsigned char _RTLENTRY _EXPDATA _osmajor;
  221. extern unsigned char _RTLENTRY _EXPDATA _osminor;
  222. extern unsigned char _RTLENTRY _EXPDATA _osmode;
  223. extern unsigned int  _RTLENTRY _EXPDATA _osversion;
  224. extern int           _RTLENTRY _EXPDATA _cmdline_escapes;
  225.  
  226.  
  227. #if !defined(__STDC__)
  228. #define sys_nerr     _sys_nerr
  229. #define sys_errlist  _sys_errlist
  230. #endif
  231.  
  232. extern char *        _RTLENTRY _EXPDATA _sys_errlist[];
  233. extern int           _RTLENTRY _EXPDATA _sys_nerr;
  234.  
  235. #ifdef __cplusplus
  236. }
  237. #endif
  238.  
  239. #if !defined(__STDC__) && !defined(__CODEGUARD__)
  240. #ifdef __cplusplus
  241.    inline int _RTLENTRY atoi(const char *__s) { return (int)atol(__s); }
  242. #else
  243. #  define atoi(__s)((int) atol(__s))
  244. #endif
  245. #endif
  246.  
  247. /* Constants for MSC pathname functions */
  248.  
  249. #define _MAX_PATH       260
  250. #define _MAX_DRIVE      3
  251. #define _MAX_DIR        256
  252. #define _MAX_FNAME      256
  253. #define _MAX_EXT        256
  254.  
  255. #ifdef __cplusplus
  256. extern "C" {
  257. #endif
  258.  
  259. long double   _RTLENTRY _EXPFUNC _atold(const char * __s);
  260.  
  261. unsigned char _RTLENTRY _EXPFUNC _crotl(unsigned char __value, int __count);
  262. unsigned char _RTLENTRY _EXPFUNC _crotr(unsigned char __value, int __count);
  263.  
  264. char *        _RTLENTRY _EXPFUNC _ecvt(double __value, int __ndig, int * __dec,
  265.                                      int * __sign);
  266. void          _RTLENTRY _EXPFUNC _exit(int __status);
  267. char *        _RTLENTRY _EXPFUNC _fcvt(double __value, int __ndig, int * __dec,
  268.                                      int * __sign);
  269. char *        _RTLENTRY _EXPFUNC _fullpath(char * __buf, const char * __path,
  270.                                      _SIZE_T __maxlen);
  271. char *        _RTLENTRY _EXPFUNC _gcvt(double __value, int __ndec,
  272.                                      char * __buf);
  273. char *        _RTLENTRY _EXPFUNC itoa(int __value, char * __string,
  274.                                      int __radix);
  275. long          _RTLENTRY _EXPFUNC _lrand(void);
  276. unsigned long _RTLENTRY _EXPFUNC _lrotl(unsigned long __val, int __count);
  277. unsigned long _RTLENTRY _EXPFUNC _lrotr(unsigned long __val, int __count);
  278.  
  279. char *        _RTLENTRY _EXPFUNC _ltoa(long __value, char * __string,
  280.                                      int __radix);
  281. void          _RTLENTRY _EXPFUNC _makepath(char * __path,
  282.                                      const char * __drive,
  283.                                      const char * __dir,
  284.                                      const char * __name,
  285.                                      const char * __ext );
  286. int           _RTLENTRY _EXPFUNC putenv(const char * __name);
  287.  
  288. unsigned short _RTLENTRY _EXPFUNC _rotl(unsigned short __value, int __count);
  289. unsigned short _RTLENTRY _EXPFUNC _rotr(unsigned short __value, int __count);
  290.  
  291. void          _RTLENTRY _EXPFUNC _searchenv(const char * __file,
  292.                                      const char * __varname,
  293.                                      char *__pathname);
  294. void          _RTLENTRY _EXPFUNC _searchstr(const char * __file,
  295.                                      const char * __ipath,
  296.                                      char *__pathname);
  297. void          _RTLENTRY _EXPFUNC _splitpath(const char * __path,
  298.                                      char * __drive,
  299.                                      char * __dir,
  300.                                      char * __name,
  301.                                      char * __ext );
  302. void          _RTLENTRY _EXPFUNC swab(char * __from, char * __to, int __nbytes);
  303. char *        _RTLENTRY _EXPFUNC ultoa(unsigned long __value, char * __string,
  304.                                      int __radix);
  305. void          _RTLENTRY _EXPFUNC perror(const char * __s);
  306.  
  307. void          _RTLENTRY _EXPFUNC _wperror(const wchar_t * __s);
  308. wchar_t *     _RTLENTRY _EXPFUNC _wfullpath(wchar_t * __buf,const wchar_t * __path,
  309.                                      _SIZE_T __maxlen);
  310. void          _RTLENTRY _EXPFUNC _wmakepath(wchar_t * __path,
  311.                                      const wchar_t * __drive,
  312.                                      const wchar_t * __dir,
  313.                                      const wchar_t * __name,
  314.                                      const wchar_t * __ext );
  315. void          _RTLENTRY _EXPFUNC _wsplitpath(const wchar_t * __path,
  316.                                      wchar_t * __drive,
  317.                                      wchar_t * __dir,
  318.                                      wchar_t * __name,
  319.                                      wchar_t * __ext );
  320.  
  321. void          _RTLENTRY _EXPFUNC _wsearchenv(const wchar_t * __file,
  322.                                      const wchar_t * __varname,
  323.                                      wchar_t *__pathname);
  324. void          _RTLENTRY _EXPFUNC _wsearchstr(const wchar_t * __file,
  325.                                      const wchar_t * __ipath,
  326.                                      wchar_t *__pathname);
  327. wchar_t *     _RTLENTRY _EXPFUNC  _wgetenv(const wchar_t * __name);
  328. int           _RTLENTRY _EXPFUNC  _wputenv(const wchar_t * __name);
  329.  
  330. #ifdef __cplusplus
  331. }
  332. #endif
  333.  
  334. #if !defined(__STDC__)
  335.  
  336. #if defined(__cplusplus)
  337. inline int  _RTLENTRY random(int __num)
  338.                        { return __num ? (int)(_lrand()%(__num)) : 0; }
  339. #else /* __cplusplus */
  340. #define random(__num) (__num ? (int)(_lrand()%(__num)) : 0)
  341. #endif  /* __cplusplus  */
  342.  
  343. #endif /* __STDC__ */
  344.  
  345. #if defined(__cplusplus)
  346. extern "C" {
  347. #endif
  348. long _RTLENTRY _EXPFUNC time(long *);
  349. #if defined(__cplusplus)
  350. }
  351. #endif
  352.  
  353. #if !defined(__STDC__)
  354.  
  355. #if defined(__cplusplus)
  356.  
  357. /* Need prototype of time() for C++ randomize() */
  358. inline void _RTLENTRY randomize(void) { srand((unsigned) time(NULL)); }
  359.  
  360. #if defined(__MFC_COMPAT__)
  361. #if !defined( __MINMAX_DEFINED)
  362. #define __MINMAX_DEFINED
  363. #define NOMINMAX    /* for WINDEF.H */
  364. #undef min  // make sure these aren't macros
  365. #undef max
  366. /*
  367.   MFC code sometimes contains usages of min() and max() of dis-similar types
  368.   which prevents using a normal template implementation.  We cannot
  369.   implement min and max as macros (like Microsoft does), since parts of the
  370.   Rogue Wave Standard Library need to #undef them.
  371.  
  372.   So we start by providing the normal template implementation and then also
  373.   provide a global, non-template version, of min and max that take and
  374.   return unsigned longs. The theory is that the compiler will first look at
  375.   the non-template version and promote both params to unsigned long before
  376.   looking at the template version and failing because of the two different
  377.   types involved.
  378. */
  379. template <class _T> inline const _T _FAR &min( const _T _FAR &__t1, const _T _FAR &__t2 )
  380. {
  381.     if  (__t1 < __t2)
  382.         return __t1;
  383.     else
  384.         return __t2;
  385. }
  386.  
  387. template <class _T> inline const _T _FAR &max( const _T _FAR &__t1, const _T _FAR &__t2 )
  388. {
  389.     if  (__t1 > __t2)
  390.         return __t1;
  391.     else
  392.         return __t2;
  393. }
  394.  
  395. inline unsigned long min (unsigned long __a, unsigned long __b)
  396. {
  397.     return min<unsigned long> (__a, __b);
  398. }
  399.  
  400. inline unsigned long max (unsigned long __a, unsigned long __b)
  401. {
  402.     return max<unsigned long> (__a, __b);
  403. }
  404. #define __max       max
  405. #define __min       min
  406. #endif /*__MINMAX_DEFINED */
  407.  
  408. inline char * _RTLENTRY  _ecvt(double __value, int __ndig, int * __dec,
  409.                             int * __sign)
  410.                             { return ecvt (__value, __ndig, __dec, __sign); }
  411. inline char * _RTLENTRY  _fcvt(double __value, int __ndig, int * __dec,
  412.                             int * __sign)
  413.                             { return fcvt (__value, __ndig, __dec, __sign); }
  414. inline char * _RTLENTRY  _gcvt(double __value, int __ndec,
  415.                             char * __buf)
  416.                             { return gcvt(__value, __ndec, __buf); }
  417. inline char * _RTLENTRY _itoa(int __value, char * __string,
  418.                             int __radix)
  419.                             { return itoa(__value, __string, __radix); }
  420. inline char * _RTLENTRY _ltoa(long __value, char * __string,
  421.                             int __radix)
  422.                             { return ltoa(__value, __string, __radix); }
  423. inline char * _RTLENTRY _ultoa(unsigned long __value, char * __string,
  424.                             int __radix)
  425.                             { return ultoa(__value, __string, __radix); }
  426. inline int    _RTLENTRY _putenv(const char * __name) {return putenv(__name);}
  427. inline void   _RTLENTRY _swab(char * __from, char * __to, int __nbytes)
  428.                             { swab (__from, __to, __nbytes); }
  429. #else   /* __MFC_COMPAT__ */
  430. #if !defined( __MINMAX_DEFINED) && defined(__cplusplus)
  431. #define __MINMAX_DEFINED
  432. #undef min  // make sure these aren't macros
  433. #undef max
  434. template <class _T> inline const _T _FAR &min( const _T _FAR &__t1, const _T _FAR &__t2 )
  435. {
  436.     if  (__t1 < __t2)
  437.         return __t1;
  438.     else
  439.         return __t2;
  440. }
  441.  
  442. template <class _T> inline const _T _FAR &max( const _T _FAR &__t1, const _T _FAR &__t2 )
  443. {
  444.     if  (__t1 > __t2)
  445.         return __t1;
  446.     else
  447.         return __t2;
  448. }
  449. #endif
  450. #endif /* __MFC_COMPAT__ */
  451.  
  452. #else /* __cplusplus */
  453.  
  454. #define randomize() srand((unsigned)time(NULL))
  455. #ifndef max
  456. #define max(__a,__b)    (((__a) > (__b)) ? (__a) : (__b))
  457. #endif
  458. #ifndef min
  459. #define min(__a,__b)    (((__a) < (__b)) ? (__a) : (__b))
  460. #endif
  461. #endif /* __cplusplus */
  462.  
  463. #endif /* __STDC__ */
  464.  
  465. #if defined(__MSC) && !defined(__MFC_COMPAT__)
  466. #define _itoa(__value, __string, __radix) itoa(__value, __string, __radix)
  467. #endif
  468.  
  469. /* argv & argc definitions */
  470.  
  471. #ifdef __cplusplus
  472. extern "C"{
  473. #endif
  474. #if !defined(__ARGV_DEFINED)
  475. #define __ARGV_DEFINED
  476.     extern int           _RTLENTRY _EXPDATA _argc;
  477.     extern char **       _RTLENTRY _EXPDATA _argv;
  478. #   define __argc        _argc  /* MSC Version */
  479. #   define __argv        _argv  /* MSC Version */
  480. #endif /* __ARGV_DEFINED */
  481. #ifdef __cplusplus
  482. } /* __cplusplus */
  483. #endif
  484.  
  485.  
  486. #if !defined(RC_INVOKED)
  487.  
  488. /* restore default packing */
  489. #pragma pack(pop)
  490.  
  491. #if defined(__STDC__)
  492. #pragma warn .nak
  493. #endif
  494.  
  495. #endif  /* !RC_INVOKED */
  496.  
  497. #ifdef __cplusplus
  498. } // std
  499. #endif /* __cplusplus */
  500.  
  501. #endif  /* __STDLIB_H */
  502.  
  503. #if defined(__cplusplus) && !defined(__USING_CNAME__) && !defined(__STDLIB_H_USING_LIST)
  504. #define __STDLIB_H_USING_LIST
  505.      using std::_argc;
  506.      using std::_argv;
  507. #ifdef _MT
  508.      using std::__doserrno;
  509.      using std::__errno;
  510. #else
  511.      using std::_doserrno;
  512.      using std::errno;
  513. #endif
  514.      using std::__mb_cur_max;
  515.  
  516.      using std::_ecvt;
  517.      using std::_atold;
  518.      using std::_cmdline_escapes;
  519.      using std::_environ;
  520.      using std::_exit;
  521.      using std::_fileinfo;
  522.      using std::_fmode;
  523.      using std::_fullpath;
  524.      using std::_fcvt;
  525.      using std::_gcvt;
  526.  
  527. #if defined(__MFC_COMPAT__)
  528.      using std::_itoa;
  529.      using std::_ultoa;
  530.      using std::_putenv;
  531.      using std::_swab;
  532. #endif
  533.  
  534.      using std::_ultow;
  535.      using std::_itow;
  536.      using std::_lrand;
  537.      using std::_ltoa;
  538.      using std::_ltow;
  539.  
  540. #if !defined(__STDC__) && defined (_INTEGRAL_MAX_BITS) && (_INTEGRAL_MAX_BITS >= 64)
  541.      using std::_atoi64;
  542.      using std::_i64toa;
  543.      using std::_i64tow;
  544.      using std::_ui64toa;
  545.      using std::_ui64tow;
  546.      using std::_wtoi64;
  547. #endif
  548.  
  549.      using std::_makepath;
  550.      using std::_osmajor;
  551.      using std::_osminor;
  552.      using std::_osmode;
  553.      using std::_osversion;
  554.      using std::_searchenv;
  555.      using std::_searchstr;
  556.      using std::_splitpath;
  557.      using std::_strtold;
  558.      using std::_sys_errlist;
  559.      using std::_sys_nerr;
  560.      using std::_wcstold;
  561.      using std::_wenviron;
  562.      using std::_wfullpath;
  563.      using std::_wgetenv;
  564.      using std::_wmakepath;
  565.      using std::_wperror;
  566.      using std::_wputenv;
  567.      using std::_wsearchenv;
  568.      using std::_wsearchstr;
  569.      using std::_wsplitpath;
  570.      using std::_wsystem;
  571.      using std::_wtof;
  572.      using std::_wtoi;
  573.      using std::_wtol;
  574.      using std::_wtold;
  575.      using std::abort;
  576.      using std::atexit;
  577.      using std::atexit_t;
  578.      using std::atof;
  579.      using std::atoi;
  580.      using std::atol;
  581.      using std::calloc;
  582.      using std::div;
  583.      using std::div_t;
  584.      using std::exit;
  585.      using std::free;
  586.      using std::getenv;
  587.      using std::itoa;
  588.      using std::labs;
  589.      using std::ldiv;
  590.      using std::ldiv_t;
  591.      using std::malloc;
  592.  
  593. #if !defined(__STDC__)
  594.      using std::ecvt;
  595.      using std::fcvt;
  596.      using std::gcvt;
  597.      using std::ltoa;
  598.      using std::random;
  599.      using std::randomize;
  600. #endif
  601.  
  602. #if !defined(__STDC__) // The standard says that min() and max() should only
  603.      using std::min;   // come in from algorith.h, but we'll allow it here
  604.      using std::max;   // unless -A is specified
  605.      using std::_seterrormode;
  606. #endif
  607.      using std::mblen;
  608.      using std::mbstowcs;
  609.      using std::mbtowc;
  610.      using std::perror;
  611.      using std::putenv;
  612.      using std::rand;
  613.      using std::realloc;
  614.      using std::srand;
  615.      using std::strtod;
  616.      using std::strtol;
  617.      using std::strtoul;
  618.      using std::swab;
  619.      using std::system;
  620.      using std::time;
  621.      using std::ultoa;
  622.      using std::wcstod;
  623.      using std::wcstol;
  624.      using std::wcstombs;
  625.      using std::wcstoul;
  626.      using std::wctomb;
  627.  
  628. /*
  629.    Handle intrinsics specially.  If intrinsics are on, the compiler creates
  630.    a macro of the normal function mapping to the __ intrinsic version, ie:
  631.      #define strcpy __strcpy__
  632.    Thus, we can test the normal name as a macro to see if it's defined, and
  633.    only preform a using statement if it's not an intrinsic
  634. */
  635.  
  636. #    ifndef abs
  637.        using std::abs;
  638. #    endif // ifndef abs
  639. #    ifndef _crotl
  640.        using std::_crotl;
  641. #    endif // ifndef _crotl
  642. #    ifndef _lrotl
  643.        using std::_lrotl;
  644. #    endif // ifndef _lrotl
  645. #    ifndef _lrotr
  646.        using std::_lrotr;
  647. #    endif // ifndef _lrotr
  648. #    ifndef _crotr
  649.        using std::_crotr;
  650. #    endif // ifndef _crotr
  651. #    ifndef _rotl
  652.        using std::_rotl;
  653. #    endif // ifndef _rotl
  654. #    ifndef _rotr
  655.        using std::_rotr;
  656. #    endif // ifndef _rotr
  657.  
  658. #endif /* __USING_CNAME__ */
  659.