/* stdlib.h Definitions for common types, variables, and functions. */ /* * C/C++ Run Time Library - Version 10.0 * * Copyright (c) 1987, 2000 by Inprise Corporation * All Rights Reserved. * */ /* $Revision: 9.20.1.0 $ */ #ifndef __STDLIB_H #define __STDLIB_H #define _INC_STDLIB /* MSC Guard name */ #ifndef ___STDDEF_H #include <_stddef.h> #endif #ifndef __SEARCH_H #include /* Factored out all the search functions to search.h */ #endif #if !defined(RC_INVOKED) #if defined(__STDC__) #pragma warn -nak #endif #endif /* !RC_INVOKED */ #ifdef __cplusplus extern "C"{ #endif /* Intrinsics must be prototyped outside of any namespace, so we list them here before entering namespace std. */ int _RTLENTRY __abs__(int); unsigned char _RTLENTRY ___crotl__(unsigned char __value, int __count); unsigned char _RTLENTRY ___crotr__(unsigned char __value, int __count); unsigned long _RTLENTRY ___lrotl__(unsigned long __val, int __count); unsigned long _RTLENTRY ___lrotr__(unsigned long __val, int __count); unsigned short _RTLENTRY ___rotl__ (unsigned short __value, int __count); unsigned short _RTLENTRY ___rotr__ (unsigned short __value, int __count); #ifdef __cplusplus } // extern "C" #endif #ifdef __cplusplus namespace std { #endif /* __cplusplus */ #if !defined(RC_INVOKED) #pragma pack(push, 1) #endif /* !RC_INVOKED */ #ifndef _DIV_T #define _DIV_T typedef struct { int quot; int rem; } div_t; #endif #ifndef _LDIV_T #define _LDIV_T typedef struct { long quot; long rem; } ldiv_t; #endif #define MB_CUR_MAX __mb_cur_max /* Maximum value returned by "rand" function */ #define RAND_MAX 0x7FFFU /* Maximum value returned by "_lrand" function (also used by random() macro) */ #define LRAND_MAX 0x7FFFFFFFU #define EXIT_SUCCESS 0 #define EXIT_FAILURE 1 typedef void (_USERENTRY * atexit_t)(void); /* These 2 constants are defined in MS's stdlib.h. */ #define DOS_MODE 0 /* DOS 16-bit */ #define OS2_MODE 1 /* OS/2 16-bit */ #ifdef __cplusplus extern "C" { #endif void _RTLENTRY _EXPFUNC abort(void); #if !defined(__ABS_DEFINED) #define __ABS_DEFINED #ifdef __cplusplus inline int _RTLENTRY abs(int __x) { return __abs__(__x); } #else int _RTLENTRY _EXPFUNC abs(int __x); # define abs(__x) __abs__(__x) #endif #endif /* __ABS_DEFINED */ int _RTLENTRY _EXPFUNC atexit(void (_USERENTRY * __func)(void)); double _RTLENTRY _EXPFUNC atof(const char * __s); int _RTLENTRY _EXPFUNC atoi(const char * __s); long _RTLENTRY _EXPFUNC atol(const char * __s); void * _RTLENTRY _EXPFUNC calloc(_SIZE_T __nitems, _SIZE_T __size); div_t _RTLENTRY _EXPFUNC div(int __numer, int __denom); void _RTLENTRY _EXPFUNC exit(int __status); void _RTLENTRY _EXPFUNC free(void * __block); char * _RTLENTRY _EXPFUNC getenv(const char * __name); long _RTLENTRY _EXPFUNC labs(long __x); ldiv_t _RTLENTRY _EXPFUNC ldiv(long __numer, long __denom); void * _RTLENTRY _EXPFUNC malloc(_SIZE_T __size); int _RTLENTRY _EXPFUNC mblen(const char * __s, _SIZE_T __n); _SIZE_T _RTLENTRY _EXPFUNC mbstowcs(wchar_t *__pwcs, const char * __s, _SIZE_T __n); int _RTLENTRY _EXPFUNC mbtowc(wchar_t *__pwc, const char * __s, _SIZE_T __n); int _RTLENTRY _EXPFUNC rand(void); void * _RTLENTRY _EXPFUNC realloc(void * __block, _SIZE_T __size); void _RTLENTRY _EXPFUNC srand(unsigned __seed); double _RTLENTRY _EXPFUNC strtod(const char * __s, char * *__endptr); long _RTLENTRY _EXPFUNC strtol(const char * __s, char * *__endptr, int __radix); long double _RTLENTRY _EXPFUNC _strtold(const char * __s, char * *__endptr); unsigned long _RTLENTRY _EXPFUNC strtoul(const char * __s, char * *__endptr, int __radix); int _RTLENTRY _EXPFUNC system(const char * __command); _SIZE_T _RTLENTRY _EXPFUNC wcstombs(char * __s, const wchar_t *__pwcs,_SIZE_T __n); int _RTLENTRY _EXPFUNC wctomb(char * __s, wchar_t __wc); double _RTLENTRY _EXPFUNC _wtof(const wchar_t * __s); int _RTLENTRY _EXPFUNC _wtoi(const wchar_t * __s); long _RTLENTRY _EXPFUNC _wtol(const wchar_t * __s); long double _RTLENTRY _EXPFUNC _wtold(const wchar_t * __s); double _RTLENTRY _EXPFUNC wcstod(const wchar_t * __s, wchar_t * *__endptr); long _RTLENTRY _EXPFUNC wcstol(const wchar_t * __s, wchar_t * *__endptr, int __radix); long double _RTLENTRY _EXPFUNC _wcstold(const wchar_t * __s, wchar_t * *__endptr); unsigned long _RTLENTRY _EXPFUNC wcstoul(const wchar_t * __s, wchar_t * *__endptr, int __radix); int _RTLENTRY _EXPFUNC _wsystem(const wchar_t * __command); wchar_t * _RTLENTRY _EXPFUNC _itow(int __value, wchar_t *__string, int __radix); wchar_t * _RTLENTRY _EXPFUNC _ltow(long __value, wchar_t *__string, int __radix); wchar_t * _RTLENTRY _EXPFUNC _ultow(unsigned long __value, wchar_t *__string, int __radix); #if !defined(__STDC__) #if defined (_INTEGRAL_MAX_BITS) && (_INTEGRAL_MAX_BITS >= 64) __int64 _RTLENTRY _EXPFUNC _atoi64(const char * __s); char * _RTLENTRY _EXPFUNC _i64toa(__int64 __value, char *__strP, int __radix); char * _RTLENTRY _EXPFUNC _ui64toa(unsigned __int64 __value, char *__strP, int __radix); __int64 _RTLENTRY _EXPFUNC _wtoi64(const wchar_t * __s); wchar_t * _RTLENTRY _EXPFUNC _i64tow(__int64 __value, wchar_t *__strP, int __radix); wchar_t * _RTLENTRY _EXPFUNC _ui64tow(unsigned __int64 __value, wchar_t *__strP, int __radix); #endif char * _RTLENTRY _EXPFUNC ltoa(long __value, char * __string, int __radix); char * _RTLENTRY _EXPFUNC ecvt(double __value, int __ndig, int * __dec, int * __sign); char * _RTLENTRY _EXPFUNC fcvt(double __value, int __ndig, int * __dec, int * __sign); char * _RTLENTRY _EXPFUNC gcvt(double __value, int __ndec, char * __buf); #endif /* __STDC__ */ /* Variables */ #ifdef _MT extern int * _RTLENTRY _EXPFUNC __errno(void); extern int * _RTLENTRY _EXPFUNC __doserrno(void); #define errno (*__errno()) #define _doserrno (*__doserrno()) #else /* MT */ extern int _RTLENTRY _EXPDATA errno; extern int _RTLENTRY _EXPDATA _doserrno; #endif /* MT */ extern int _RTLENTRY _EXPDATA __mb_cur_max; #if !defined(__STDC__) /* Values for _osmode */ #define _WIN_MODE 2 /* Windows 16- or 32-bit */ #define _OS2_20_MODE 3 /* OS/2 32-bit */ #define _DOSX32_MODE 4 /* DOS 32-bit */ #define environ _environ /* MSC compatible routines: */ void _RTLENTRY _EXPFUNC _seterrormode(int __mode); #endif /* __STDC__ */ extern char ** _RTLENTRY _EXPDATA _environ; extern wchar_t ** _RTLENTRY _EXPDATA _wenviron; extern int _RTLENTRY _EXPDATA _fileinfo; extern int _RTLENTRY _fmode; extern unsigned char _RTLENTRY _EXPDATA _osmajor; extern unsigned char _RTLENTRY _EXPDATA _osminor; extern unsigned char _RTLENTRY _EXPDATA _osmode; extern unsigned int _RTLENTRY _EXPDATA _osversion; extern int _RTLENTRY _EXPDATA _cmdline_escapes; #if !defined(__STDC__) #define sys_nerr _sys_nerr #define sys_errlist _sys_errlist #endif extern char * _RTLENTRY _EXPDATA _sys_errlist[]; extern int _RTLENTRY _EXPDATA _sys_nerr; #ifdef __cplusplus } #endif #if !defined(__STDC__) && !defined(__CODEGUARD__) #ifdef __cplusplus inline int _RTLENTRY atoi(const char *__s) { return (int)atol(__s); } #else # define atoi(__s)((int) atol(__s)) #endif #endif /* Constants for MSC pathname functions */ #define _MAX_PATH 260 #define _MAX_DRIVE 3 #define _MAX_DIR 256 #define _MAX_FNAME 256 #define _MAX_EXT 256 #ifdef __cplusplus extern "C" { #endif long double _RTLENTRY _EXPFUNC _atold(const char * __s); unsigned char _RTLENTRY _EXPFUNC _crotl(unsigned char __value, int __count); unsigned char _RTLENTRY _EXPFUNC _crotr(unsigned char __value, int __count); char * _RTLENTRY _EXPFUNC _ecvt(double __value, int __ndig, int * __dec, int * __sign); void _RTLENTRY _EXPFUNC _exit(int __status); char * _RTLENTRY _EXPFUNC _fcvt(double __value, int __ndig, int * __dec, int * __sign); char * _RTLENTRY _EXPFUNC _fullpath(char * __buf, const char * __path, _SIZE_T __maxlen); char * _RTLENTRY _EXPFUNC _gcvt(double __value, int __ndec, char * __buf); char * _RTLENTRY _EXPFUNC itoa(int __value, char * __string, int __radix); long _RTLENTRY _EXPFUNC _lrand(void); unsigned long _RTLENTRY _EXPFUNC _lrotl(unsigned long __val, int __count); unsigned long _RTLENTRY _EXPFUNC _lrotr(unsigned long __val, int __count); char * _RTLENTRY _EXPFUNC _ltoa(long __value, char * __string, int __radix); void _RTLENTRY _EXPFUNC _makepath(char * __path, const char * __drive, const char * __dir, const char * __name, const char * __ext ); int _RTLENTRY _EXPFUNC putenv(const char * __name); unsigned short _RTLENTRY _EXPFUNC _rotl(unsigned short __value, int __count); unsigned short _RTLENTRY _EXPFUNC _rotr(unsigned short __value, int __count); void _RTLENTRY _EXPFUNC _searchenv(const char * __file, const char * __varname, char *__pathname); void _RTLENTRY _EXPFUNC _searchstr(const char * __file, const char * __ipath, char *__pathname); void _RTLENTRY _EXPFUNC _splitpath(const char * __path, char * __drive, char * __dir, char * __name, char * __ext ); void _RTLENTRY _EXPFUNC swab(char * __from, char * __to, int __nbytes); char * _RTLENTRY _EXPFUNC ultoa(unsigned long __value, char * __string, int __radix); void _RTLENTRY _EXPFUNC perror(const char * __s); void _RTLENTRY _EXPFUNC _wperror(const wchar_t * __s); wchar_t * _RTLENTRY _EXPFUNC _wfullpath(wchar_t * __buf,const wchar_t * __path, _SIZE_T __maxlen); void _RTLENTRY _EXPFUNC _wmakepath(wchar_t * __path, const wchar_t * __drive, const wchar_t * __dir, const wchar_t * __name, const wchar_t * __ext ); void _RTLENTRY _EXPFUNC _wsplitpath(const wchar_t * __path, wchar_t * __drive, wchar_t * __dir, wchar_t * __name, wchar_t * __ext ); void _RTLENTRY _EXPFUNC _wsearchenv(const wchar_t * __file, const wchar_t * __varname, wchar_t *__pathname); void _RTLENTRY _EXPFUNC _wsearchstr(const wchar_t * __file, const wchar_t * __ipath, wchar_t *__pathname); wchar_t * _RTLENTRY _EXPFUNC _wgetenv(const wchar_t * __name); int _RTLENTRY _EXPFUNC _wputenv(const wchar_t * __name); #ifdef __cplusplus } #endif #if !defined(__STDC__) #if defined(__cplusplus) inline int _RTLENTRY random(int __num) { return __num ? (int)(_lrand()%(__num)) : 0; } #else /* __cplusplus */ #define random(__num) (__num ? (int)(_lrand()%(__num)) : 0) #endif /* __cplusplus */ #endif /* __STDC__ */ #if defined(__cplusplus) extern "C" { #endif long _RTLENTRY _EXPFUNC time(long *); #if defined(__cplusplus) } #endif #if !defined(__STDC__) #if defined(__cplusplus) /* Need prototype of time() for C++ randomize() */ inline void _RTLENTRY randomize(void) { srand((unsigned) time(NULL)); } #if defined(__MFC_COMPAT__) #if !defined( __MINMAX_DEFINED) #define __MINMAX_DEFINED #define NOMINMAX /* for WINDEF.H */ #undef min // make sure these aren't macros #undef max /* MFC code sometimes contains usages of min() and max() of dis-similar types which prevents using a normal template implementation. We cannot implement min and max as macros (like Microsoft does), since parts of the Rogue Wave Standard Library need to #undef them. So we start by providing the normal template implementation and then also provide a global, non-template version, of min and max that take and return unsigned longs. The theory is that the compiler will first look at the non-template version and promote both params to unsigned long before looking at the template version and failing because of the two different types involved. */ template inline const _T _FAR &min( const _T _FAR &__t1, const _T _FAR &__t2 ) { if (__t1 < __t2) return __t1; else return __t2; } template inline const _T _FAR &max( const _T _FAR &__t1, const _T _FAR &__t2 ) { if (__t1 > __t2) return __t1; else return __t2; } inline unsigned long min (unsigned long __a, unsigned long __b) { return min (__a, __b); } inline unsigned long max (unsigned long __a, unsigned long __b) { return max (__a, __b); } #define __max max #define __min min #endif /*__MINMAX_DEFINED */ inline char * _RTLENTRY _ecvt(double __value, int __ndig, int * __dec, int * __sign) { return ecvt (__value, __ndig, __dec, __sign); } inline char * _RTLENTRY _fcvt(double __value, int __ndig, int * __dec, int * __sign) { return fcvt (__value, __ndig, __dec, __sign); } inline char * _RTLENTRY _gcvt(double __value, int __ndec, char * __buf) { return gcvt(__value, __ndec, __buf); } inline char * _RTLENTRY _itoa(int __value, char * __string, int __radix) { return itoa(__value, __string, __radix); } inline char * _RTLENTRY _ltoa(long __value, char * __string, int __radix) { return ltoa(__value, __string, __radix); } inline char * _RTLENTRY _ultoa(unsigned long __value, char * __string, int __radix) { return ultoa(__value, __string, __radix); } inline int _RTLENTRY _putenv(const char * __name) {return putenv(__name);} inline void _RTLENTRY _swab(char * __from, char * __to, int __nbytes) { swab (__from, __to, __nbytes); } #else /* __MFC_COMPAT__ */ #if !defined( __MINMAX_DEFINED) && defined(__cplusplus) #define __MINMAX_DEFINED #undef min // make sure these aren't macros #undef max template inline const _T _FAR &min( const _T _FAR &__t1, const _T _FAR &__t2 ) { if (__t1 < __t2) return __t1; else return __t2; } template inline const _T _FAR &max( const _T _FAR &__t1, const _T _FAR &__t2 ) { if (__t1 > __t2) return __t1; else return __t2; } #endif #endif /* __MFC_COMPAT__ */ #else /* __cplusplus */ #define randomize() srand((unsigned)time(NULL)) #ifndef max #define max(__a,__b) (((__a) > (__b)) ? (__a) : (__b)) #endif #ifndef min #define min(__a,__b) (((__a) < (__b)) ? (__a) : (__b)) #endif #endif /* __cplusplus */ #endif /* __STDC__ */ #if defined(__MSC) && !defined(__MFC_COMPAT__) #define _itoa(__value, __string, __radix) itoa(__value, __string, __radix) #endif /* argv & argc definitions */ #ifdef __cplusplus extern "C"{ #endif #if !defined(__ARGV_DEFINED) #define __ARGV_DEFINED extern int _RTLENTRY _EXPDATA _argc; extern char ** _RTLENTRY _EXPDATA _argv; # define __argc _argc /* MSC Version */ # define __argv _argv /* MSC Version */ #endif /* __ARGV_DEFINED */ #ifdef __cplusplus } /* __cplusplus */ #endif #if !defined(RC_INVOKED) /* restore default packing */ #pragma pack(pop) #if defined(__STDC__) #pragma warn .nak #endif #endif /* !RC_INVOKED */ #ifdef __cplusplus } // std #endif /* __cplusplus */ #endif /* __STDLIB_H */ #if defined(__cplusplus) && !defined(__USING_CNAME__) && !defined(__STDLIB_H_USING_LIST) #define __STDLIB_H_USING_LIST using std::_argc; using std::_argv; #ifdef _MT using std::__doserrno; using std::__errno; #else using std::_doserrno; using std::errno; #endif using std::__mb_cur_max; using std::_ecvt; using std::_atold; using std::_cmdline_escapes; using std::_environ; using std::_exit; using std::_fileinfo; using std::_fmode; using std::_fullpath; using std::_fcvt; using std::_gcvt; #if defined(__MFC_COMPAT__) using std::_itoa; using std::_ultoa; using std::_putenv; using std::_swab; #endif using std::_ultow; using std::_itow; using std::_lrand; using std::_ltoa; using std::_ltow; #if !defined(__STDC__) && defined (_INTEGRAL_MAX_BITS) && (_INTEGRAL_MAX_BITS >= 64) using std::_atoi64; using std::_i64toa; using std::_i64tow; using std::_ui64toa; using std::_ui64tow; using std::_wtoi64; #endif using std::_makepath; using std::_osmajor; using std::_osminor; using std::_osmode; using std::_osversion; using std::_searchenv; using std::_searchstr; using std::_splitpath; using std::_strtold; using std::_sys_errlist; using std::_sys_nerr; using std::_wcstold; using std::_wenviron; using std::_wfullpath; using std::_wgetenv; using std::_wmakepath; using std::_wperror; using std::_wputenv; using std::_wsearchenv; using std::_wsearchstr; using std::_wsplitpath; using std::_wsystem; using std::_wtof; using std::_wtoi; using std::_wtol; using std::_wtold; using std::abort; using std::atexit; using std::atexit_t; using std::atof; using std::atoi; using std::atol; using std::calloc; using std::div; using std::div_t; using std::exit; using std::free; using std::getenv; using std::itoa; using std::labs; using std::ldiv; using std::ldiv_t; using std::malloc; #if !defined(__STDC__) using std::ecvt; using std::fcvt; using std::gcvt; using std::ltoa; using std::random; using std::randomize; #endif #if !defined(__STDC__) // The standard says that min() and max() should only using std::min; // come in from algorith.h, but we'll allow it here using std::max; // unless -A is specified using std::_seterrormode; #endif using std::mblen; using std::mbstowcs; using std::mbtowc; using std::perror; using std::putenv; using std::rand; using std::realloc; using std::srand; using std::strtod; using std::strtol; using std::strtoul; using std::swab; using std::system; using std::time; using std::ultoa; using std::wcstod; using std::wcstol; using std::wcstombs; using std::wcstoul; using std::wctomb; /* Handle intrinsics specially. If intrinsics are on, the compiler creates a macro of the normal function mapping to the __ intrinsic version, ie: #define strcpy __strcpy__ Thus, we can test the normal name as a macro to see if it's defined, and only preform a using statement if it's not an intrinsic */ # ifndef abs using std::abs; # endif // ifndef abs # ifndef _crotl using std::_crotl; # endif // ifndef _crotl # ifndef _lrotl using std::_lrotl; # endif // ifndef _lrotl # ifndef _lrotr using std::_lrotr; # endif // ifndef _lrotr # ifndef _crotr using std::_crotr; # endif // ifndef _crotr # ifndef _rotl using std::_rotl; # endif // ifndef _rotl # ifndef _rotr using std::_rotr; # endif // ifndef _rotr #endif /* __USING_CNAME__ */