home *** CD-ROM | disk | FTP | other *** search
/ PC Format (South-Africa) 2001 June / PCFJune.iso / Xenon / C++ / FreeCommandLineTools.exe / Include / stdio.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-31  |  18.3 KB  |  494 lines
  1. /*  stdio.h
  2.  
  3.     Definitions for stream input/output.
  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.10  $ */
  16.  
  17. #ifndef __STDIO_H
  18. #define __STDIO_H
  19. #define _INC_STDIO  /* MSC Guard name */
  20.  
  21. #ifndef ___STDDEF_H
  22. #include <_stddef.h>
  23. #endif
  24.  
  25. #if !defined(___NFILE_H)
  26. #include <_nfile.h>
  27. #endif
  28.  
  29. #ifdef __cplusplus
  30. namespace std {
  31. #endif /* __cplusplus */
  32.  
  33.  
  34. #if !defined(RC_INVOKED)
  35.  
  36. #if defined(__STDC__)
  37. #pragma warn -nak
  38. #endif
  39.  
  40. #pragma pack(push, 1)
  41.  
  42. #endif  /* !RC_INVOKED */
  43.  
  44. /* Definition of the file position type
  45. */
  46. typedef long    fpos_t;
  47.  
  48. /* An external reference to _floatconvert (using #pragma extref _floatconvert)
  49.  * forces floating point format conversions to be linked.
  50.  */
  51. extern int _floatconvert;
  52.  
  53. /* Bufferisation type to be used as 3rd argument for "setvbuf" function
  54. */
  55. #define _IOFBF  0
  56. #define _IOLBF  1
  57. #define _IONBF  2
  58.  
  59. /*  "flags" bits definitions
  60. */
  61. #define _F_RDWR 0x0003                  /* Read/write flag       */
  62. #define _F_READ 0x0001                  /* Read only file        */
  63. #define _F_WRIT 0x0002                  /* Write only file       */
  64. #define _F_BUF  0x0004                  /* Malloc'ed Buffer data */
  65. #define _F_LBUF 0x0008                  /* line-buffered file    */
  66. #define _F_ERR  0x0010                  /* Error indicator       */
  67. #define _F_EOF  0x0020                  /* EOF indicator         */
  68. #define _F_BIN  0x0040                  /* Binary file indicator */
  69. #define _F_IN   0x0080                  /* Data is incoming      */
  70. #define _F_OUT  0x0100                  /* Data is outgoing      */
  71. #define _F_TERM 0x0200                  /* File is a terminal    */
  72.  
  73. /* End-of-file constant definition
  74. */
  75. #define EOF (-1)                /* End of file indicator */
  76. #define WEOF (_WINT_T)(0xFFFF)   /* wide-character end of file indicator */
  77.  
  78. /* Default buffer size use by "setbuf" function
  79. */
  80. #define BUFSIZ  512         /* Buffer size for stdio */
  81.  
  82. /* Size of an arry large enough to hold a temporary file name string
  83. */
  84. #define L_ctermid   5       /* CON: plus null byte */
  85. #define P_tmpdir    ""      /* temporary directory */
  86. #define L_tmpnam    13      /* tmpnam buffer size */
  87.  
  88. /* Constants to be used as 3rd argument for "fseek" function
  89. */
  90. #define SEEK_CUR    1
  91. #define SEEK_END    2
  92. #define SEEK_SET    0
  93.  
  94. /* Number of unique file names that shall be generated by "tmpnam" function
  95. */
  96. #define TMP_MAX     0xFFFF
  97.  
  98. /* Definition of the control structure for streams
  99. */
  100. typedef struct
  101. {
  102.         unsigned char  *curp;       /* Current active pointer     */
  103.         unsigned char  *buffer;     /* Data transfer buffer       */
  104.         int             level;      /* fill/empty level of buffer */
  105.         int             bsize;      /* Buffer size                */
  106.         unsigned short  istemp;     /* Temporary file indicator   */
  107.         unsigned short  flags;      /* File status flags          */
  108.         wchar_t         hold;       /* Ungetc char if no buffer   */
  109.         char            fd;         /* File descriptor            */
  110.         unsigned char   token;      /* Used for validity checking */
  111. }       FILE;                       /* This is the FILE object    */
  112.  
  113. /* Number of files that can be open simultaneously
  114. */
  115. #if defined(__STDC__)
  116. #define FOPEN_MAX (_NFILE_)
  117. #else
  118. #define FOPEN_MAX (_NFILE_)
  119. #define SYS_OPEN  (_NFILE_)
  120. #endif
  121.  
  122. #define FILENAME_MAX 260
  123.  
  124. #ifdef __cplusplus
  125. extern "C" {
  126. #endif
  127.  
  128. /* Standard I/O predefined streams
  129. */
  130. extern  FILE        _RTLENTRY _EXPDATA _streams[];
  131. extern  unsigned    _RTLENTRY _EXPDATA _nfile;
  132.  
  133. #define stdin   (&_streams[0])
  134. #define stdout  (&_streams[1])
  135. #define stderr  (&_streams[2])
  136.  
  137. /* __getStream() is used internally with CG only, but prototyped here for
  138.   consistancy with the 16-bit version.
  139. */
  140. FILE * _RTLENTRY _EXPFUNC __getStream( int );
  141. #ifdef __cplusplus
  142. }
  143. #endif
  144.  
  145.  
  146. #ifdef __cplusplus
  147. extern "C" {
  148. #endif
  149. void      _RTLENTRY _EXPFUNC clearerr(FILE * __stream);
  150. int       _RTLENTRY _EXPFUNC fclose(FILE * __stream);
  151. int       _RTLENTRY _EXPFUNC fflush(FILE * __stream);
  152. int       _RTLENTRY _EXPFUNC fgetc(FILE * __stream);
  153. _WINT_T   _RTLENTRY _EXPFUNC fgetwc(FILE * __stream);
  154. int       _RTLENTRY _EXPFUNC fgetpos(FILE * __stream, fpos_t*__pos);
  155. char  *   _RTLENTRY _EXPFUNC fgets(char * __s, int __n, FILE * __stream);
  156. wchar_t*  _RTLENTRY _EXPFUNC fgetws(wchar_t * __s, int __n, FILE * __stream);
  157. FILE  *   _RTLENTRY _EXPFUNC fopen(const char * __path, const char * __mode);
  158. FILE  *   _RTLENTRY _EXPFUNC _wfopen(const wchar_t * __path,
  159.                                  const wchar_t * __mode);
  160. int       _RTLENTRY _EXPFUNC fprintf(FILE * __stream, const char * __format, ...);
  161. int       _RTLENTRY _EXPFUNC fwprintf(FILE * __stream, const wchar_t *__format, ...);
  162. int       _RTLENTRY _EXPFUNC fputc(int __c, FILE * __stream);
  163. _WINT_T   _RTLENTRY _EXPFUNC fputwc(_WINT_T __c, FILE * __stream);
  164. int       _RTLENTRY _EXPFUNC fputs(const char * __s, FILE * __stream);
  165. int       _RTLENTRY _EXPFUNC fputws(const wchar_t * __s, FILE * __stream);
  166. _SIZE_T   _RTLENTRY _EXPFUNC fread(void * __ptr, _SIZE_T __size, _SIZE_T __n,
  167.                                  FILE * __stream);
  168. FILE  *   _RTLENTRY _EXPFUNC freopen(const char * __path, const char * __mode,
  169.                                  FILE * __stream);
  170. FILE  *   _RTLENTRY _EXPFUNC _wfreopen(const wchar_t * __path, const wchar_t * __mode,
  171.                                  FILE * __stream);
  172. int       _RTLENTRY _EXPFUNC fscanf(FILE * __stream, const char * __format, ...);
  173. int       _RTLENTRY _EXPFUNC fwscanf(FILE *__stream, const wchar_t *__format, ...);
  174. int       _RTLENTRY _EXPFUNC fseek(FILE * __stream, long __offset, int __whence);
  175. int       _RTLENTRY _EXPFUNC fsetpos(FILE * __stream, const fpos_t*__pos);
  176. long      _RTLENTRY _EXPFUNC ftell(FILE * __stream);
  177. _SIZE_T   _RTLENTRY _EXPFUNC fwrite(const void * __ptr, _SIZE_T __size, _SIZE_T __n,
  178.                                  FILE * __stream);
  179. char  *   _RTLENTRY _EXPFUNC gets(char * __s);
  180. wchar_t*  _RTLENTRY _EXPFUNC _getws(wchar_t * __s);
  181. int       _RTLENTRY _EXPFUNC _pclose(FILE *__stream);
  182. void      _RTLENTRY _EXPFUNC perror(const char * __s);
  183. void      _RTLENTRY _EXPFUNC _wperror(const wchar_t * __s);
  184. FILE *    _RTLENTRY _EXPFUNC _popen(const char * __command, const char * __mode);
  185. FILE *    _RTLENTRY _EXPFUNC _wpopen(const wchar_t * __command,
  186.                                  const wchar_t * __mode);
  187.  
  188. int       _RTLENTRY _EXPFUNC printf(const char * __format, ...);
  189. int       _RTLENTRY _EXPFUNC wprintf(const wchar_t * __format, ...);
  190. int       _RTLENTRY _EXPFUNC puts(const char * __s);
  191. int       _RTLENTRY _EXPFUNC _putws(const wchar_t * __s);
  192.  
  193. int       _RTLENTRY _EXPFUNC remove(const char * __path);
  194. int       _RTLENTRY _EXPFUNC _wremove(const wchar_t * __path);
  195. int       _RTLENTRY _EXPFUNC rename(const char * __oldname,const char * __newname);
  196. int       _RTLENTRY _EXPFUNC _wrename(const wchar_t * __oldname,const wchar_t * __newname);
  197. void      _RTLENTRY _EXPFUNC rewind(FILE * __stream);
  198. int       _RTLENTRY _EXPFUNC scanf(const char * __format, ...);
  199. int       _RTLENTRY _EXPFUNC wscanf(const wchar_t * __format, ...);
  200. void      _RTLENTRY _EXPFUNC setbuf(FILE * __stream, char * __buf);
  201. int       _RTLENTRY _EXPFUNC setvbuf(FILE * __stream, char * __buf,
  202.                                  int __type, _SIZE_T __size);
  203. int       _RTLENTRY _EXPFUNC sprintf(char * __buffer, const char * __format, ...);
  204. int       _RTLENTRY _EXPFUNC swprintf(wchar_t * __buffer, const wchar_t * __format, ...);
  205. int       _RTLENTRY _EXPFUNC snprintf(char * __buffer, _SIZE_T __nsize,
  206.                                  const char * __format, ...);
  207. int       _RTLENTRY _EXPFUNC snwprintf(wchar_t * __buffer, _SIZE_T __nsize,
  208.                                  const wchar_t * __format, ...);
  209. #ifndef __STDC__
  210. int       _RTLENTRY _EXPFUNC _snprintf(char * __buffer, _SIZE_T __nsize,
  211.                                  const char * __format, ...);
  212. int       _RTLENTRY _EXPFUNC _snwprintf(wchar_t * __buffer, _SIZE_T __nsize,
  213.                                  const wchar_t * __format, ...);
  214. #endif
  215. int       _RTLENTRY _EXPFUNC sscanf(const char * __buffer,
  216.                                  const char * __format, ...);
  217. int       _RTLENTRY _EXPFUNC swscanf(const wchar_t * __buffer,
  218.                                  const wchar_t * __format, ...);
  219. char  *   _RTLENTRY _EXPFUNC strerror(int __errnum);
  220. FILE  *   _RTLENTRY _EXPFUNC tmpfile(void);
  221. char  *   _RTLENTRY _EXPFUNC tmpnam(char * __s);
  222. wchar_t * _RTLENTRY _EXPFUNC _wtmpnam(wchar_t * __s);
  223. int       _RTLENTRY _EXPFUNC ungetc(int __c, FILE * __stream);
  224. _WINT_T   _RTLENTRY _EXPFUNC ungetwc(_WINT_T __c, FILE * __stream);
  225. int       _RTLENTRY _EXPFUNC vfprintf(FILE * __stream, const char * __format,
  226.                                  void * __arglist);
  227. int       _RTLENTRY _EXPFUNC vfscanf(FILE * __stream, const char * __format,
  228.                                  void * __arglist);
  229. int       _RTLENTRY _EXPFUNC vprintf(const char * __format, void * __arglist);
  230. int       _RTLENTRY _EXPFUNC vscanf(const char * __format, void * __arglist);
  231. int       _RTLENTRY _EXPFUNC vsprintf(char * __buffer, const char * __format,
  232.                                  void * __arglist);
  233. int       _RTLENTRY _EXPFUNC vsnprintf(char * __buffer, _SIZE_T __nsize, const char * __format,
  234.                                  void * __arglist);
  235. int       _RTLENTRY _EXPFUNC vsscanf(const char * __buffer, const char * __format,
  236.                                  void * __arglist);
  237. int       _RTLENTRY _EXPFUNC vfwprintf(FILE * __stream, const wchar_t * __format,
  238.                                  void * __arglist);
  239. int       _RTLENTRY _EXPFUNC vfwscanf(FILE * __stream, const wchar_t * __format,
  240.                                  void * __arglist);
  241. int       _RTLENTRY _EXPFUNC vwprintf(const wchar_t * __format, void * __arglist);
  242. int       _RTLENTRY _EXPFUNC vwscanf(const wchar_t * __format, void * __arglist);
  243. int       _RTLENTRY _EXPFUNC vswprintf(wchar_t * __buffer, const wchar_t * __format,
  244.                                  void * __arglist);
  245. int       _RTLENTRY _EXPFUNC vsnwprintf(wchar_t * __buffer, _SIZE_T __nsize, const wchar_t * __format,
  246.                                  void * __arglist);
  247. int       _RTLENTRY _EXPFUNC vswscanf(const wchar_t * __buffer, const wchar_t * __format,
  248.                                  void * __arglist);
  249. int       _RTLENTRY _EXPFUNC _unlink(const char * __path);
  250. int       _RTLENTRY _EXPFUNC _wunlink(const wchar_t * __path);
  251. #ifndef   __STDC__
  252. int       _RTLENTRY _EXPFUNC _vsnprintf(char * __buffer, _SIZE_T __nsize, const char * __format,
  253.                                  void * __arglist);
  254. int       _RTLENTRY _EXPFUNC _vsnwprintf(wchar_t * __buffer, _SIZE_T __nsize, const wchar_t * __format,
  255.                                  void * __arglist);
  256. #endif
  257.  
  258. int       _RTLENTRY _EXPFUNC getc(FILE * __fp);
  259. _WINT_T   _RTLENTRY _EXPFUNC getwc(FILE * __fp);
  260. int       _RTLENTRY _EXPFUNC getchar(void);
  261. _WINT_T   _RTLENTRY _EXPFUNC getwchar(void);
  262. int       _RTLENTRY _EXPFUNC putchar(const int __c);
  263. _WINT_T   _RTLENTRY _EXPFUNC putwchar(const _WINT_T __c);
  264. int       _RTLENTRY _EXPFUNC putc(const int __c, FILE * __fp);
  265. _WINT_T   _RTLENTRY _EXPFUNC putwc(const _WINT_T __c, FILE * __fp);
  266. int       _RTLENTRY _EXPFUNC feof(FILE * __fp);
  267. int       _RTLENTRY _EXPFUNC ferror(FILE * __fp);
  268. int       _RTLENTRY _EXPFUNC _fileno(FILE _FAR *__fp);
  269. int       _RTLENTRY _EXPFUNC _flushall(void);
  270. int       _RTLENTRY _EXPFUNC _fcloseall(void);
  271. FILE  *   _RTLENTRY _EXPFUNC _fdopen(int __handle, char * __type);
  272. FILE  *   _RTLENTRY _EXPFUNC _wfdopen(int __handle, wchar_t * __type);
  273. int       _RTLENTRY _EXPFUNC _fgetchar(void);
  274. _WINT_T   _RTLENTRY _EXPFUNC _fgetwchar(void);
  275. int       _RTLENTRY _EXPFUNC _fputchar(int __c);
  276. _WINT_T   _RTLENTRY _EXPFUNC _fputwchar(_WINT_T __c);
  277. FILE  *   _RTLENTRY _EXPFUNC _fsopen (const char * __path, const char * __mode, int __shflag);
  278. FILE  *   _RTLENTRY _EXPFUNC _wfsopen (const wchar_t * __path,
  279.                                  const wchar_t * __mode, int __shflag);
  280. #ifdef __IN_SOPEN
  281. int       _RTLENTRY _EXPFUNC _sopen ();
  282. #else
  283. int       _RTLENTRY _EXPFUNC _sopen (const char *__path, int __access, int __shflag,
  284.                                  ... /* unsigned mode */);
  285. #endif
  286. int       _RTLENTRY _EXPFUNC _wsopen (const wchar_t *__path, int __access, int __shflag,
  287.                                  ... /* unsigned mode */);
  288. int       _RTLENTRY _EXPFUNC _getw(FILE * __stream);
  289. int       _RTLENTRY _EXPFUNC _putw(int __w, FILE * __stream);
  290. int       _RTLENTRY _EXPFUNC _rmtmp(void);
  291. char  *   _RTLENTRY _EXPFUNC _strerror(const char * __s);
  292. char  *   _RTLENTRY _EXPFUNC _tempnam(char * __dir, char * __pfx);
  293. wchar_t * _RTLENTRY _EXPFUNC _wtempnam(wchar_t * __dir, wchar_t * __pfx);
  294. int       _RTLENTRY _EXPFUNC _fgetc(FILE * __stream);           /* used by getc() macro */
  295. _WINT_T   _RTLENTRY _EXPFUNC _fgetwc(FILE * __stream);
  296. int       _RTLENTRY _EXPFUNC _fputc(char __c, FILE * __stream); /* used by putc() macro */
  297. _WINT_T   _RTLENTRY _EXPFUNC _fputwc(wchar_t __c, FILE * __stream);
  298. #if !defined(__STDC__)
  299. int       _RTLENTRY _EXPFUNC flushall(void);
  300. FILE  *   _RTLENTRY _EXPFUNC fdopen(int __handle, char * __type);
  301. int       _RTLENTRY _EXPFUNC fputchar(int __c);
  302. int       _RTLENTRY _EXPFUNC fgetchar(void);
  303. int       _RTLENTRY _EXPFUNC fileno(FILE * __fp);
  304. int       _RTLENTRY _EXPFUNC fcloseall(void);
  305. char  *   _RTLENTRY _EXPFUNC tempnam(char * __dir, char * __pfx);
  306. int       _RTLENTRY _EXPFUNC rmtmp(void);
  307. int       _RTLENTRY _EXPFUNC unlink(const char * __path);
  308. int       _RTLENTRY _EXPFUNC getw(FILE * __stream);
  309. int       _RTLENTRY _EXPFUNC putw(int __w, FILE * __stream);
  310. int       _RTLENTRY _EXPFUNC sopen (const char *__path, int __access, int __shflag,
  311.                                  ... /* unsigned mode */);
  312. #endif
  313. #ifdef  __cplusplus
  314. }
  315. #endif
  316.  
  317. /*  The following macros provide for common functions */
  318.  
  319. #if !defined(__CODEGUARD__)
  320.  
  321. #define ferror(__f)   ((__f)->flags & _F_ERR)
  322. #define feof(__f)     ((__f)->flags & _F_EOF)
  323. #define fileno(__f)   ((__f)->fd)
  324. #define _fileno(__f)   ((__f)->fd)
  325.  
  326. #define getc(__f) \
  327.   ((--((__f)->level) >= 0) ? (unsigned char)(*(__f)->curp++) : \
  328.     _fgetc (__f))
  329.  
  330. #define putc(__c,__f) \
  331.   ((++((__f)->level) < 0) ? (unsigned char)(*(__f)->curp++=(__c)) : \
  332.     _fputc (((char)(__c)),__f))
  333.  
  334. #define getchar()   getc(stdin)
  335. #define getwchar()  getwc(stdin)
  336. #define putchar(__c)  putc((__c), stdout)
  337. #define putwchar(__c) putwc((__c), stdout)
  338.  
  339. #endif
  340.  
  341. #define ungetc(__c,__f) ungetc((__c),__f)   /* traditionally a macro */
  342.  
  343. #if !defined(RC_INVOKED)
  344.  
  345. /* restore default packing */
  346. #pragma pack(pop)
  347.  
  348. #if defined(__STDC__)
  349. #pragma warn .nak
  350. #endif
  351.  
  352. #endif  /* !RC_INVOKED */
  353.  
  354. #ifdef __cplusplus
  355. } // std
  356. #endif /* __cplusplus */
  357.  
  358. #endif  /* __STDIO_H */
  359.  
  360. #if defined(__cplusplus) && !defined(__USING_CNAME__) && !defined(__STDIO_H_USING_LIST)
  361. #define __STDIO_H_USING_LIST
  362.      using std::FILE;
  363.      using std::__getStream;
  364.      using std::_fcloseall;
  365.      using std::_fdopen;
  366.      using std::_fgetc;
  367.      using std::_fgetchar;
  368.      using std::_fgetwc;
  369.      using std::_fgetwchar;
  370.      using std::_fileno;
  371.      using std::_floatconvert;
  372.      using std::_flushall;
  373.      using std::_fputc;
  374.      using std::_fputchar;
  375.      using std::_fputwc;
  376.      using std::_fputwchar;
  377.      using std::_fsopen;
  378.      using std::_getw;
  379.      using std::_getws;
  380.      using std::_pclose;
  381.      using std::_popen;
  382.      using std::_putw;
  383.      using std::_putws;
  384.      using std::_rmtmp;
  385.      using std::_sopen;
  386.      using std::_streams;
  387.      using std::_strerror;
  388.      using std::_tempnam;
  389.      using std::_unlink;
  390.      using std::_wfdopen;
  391.      using std::_wfopen;
  392.      using std::_wfreopen;
  393.      using std::_wfsopen;
  394.      using std::_wperror;
  395.      using std::_wpopen;
  396.      using std::_wremove;
  397.      using std::_wrename;
  398.      using std::_wsopen;
  399.      using std::_wtempnam;
  400.      using std::_wtmpnam;
  401.      using std::_wunlink;
  402.      using std::clearerr;
  403.      using std::fclose;
  404.      using std::feof;
  405.      using std::ferror;
  406.      using std::fflush;
  407.      using std::fgetc;
  408.      using std::fgetpos;
  409.      using std::fgets;
  410.      using std::fgetwc;
  411.      using std::fgetws;
  412.      using std::fopen;
  413.      using std::fpos_t;
  414.      using std::fprintf;
  415.      using std::fputc;
  416.      using std::fputs;
  417.      using std::fputwc;
  418.      using std::fputws;
  419.      using std::fread;
  420.      using std::freopen;
  421.      using std::fscanf;
  422.      using std::fseek;
  423.      using std::fsetpos;
  424.      using std::ftell;
  425.      using std::fwprintf;
  426.      using std::fwrite;
  427.      using std::fwscanf;
  428.      using std::getc;
  429.      using std::getchar;
  430.      using std::gets;
  431.      using std::getwc;
  432.      using std::getwchar;
  433.      using std::perror;
  434.      using std::printf;
  435.      using std::putc;
  436.      using std::putchar;
  437.      using std::puts;
  438.      using std::putwc;
  439.      using std::putwchar;
  440.      using std::remove;
  441.      using std::rename;
  442.      using std::rewind;
  443.      using std::scanf;
  444.      using std::setbuf;
  445.      using std::setvbuf;
  446.      using std::snprintf;
  447.      using std::snwprintf;
  448.      using std::sprintf;
  449.      using std::sscanf;
  450.      using std::strerror;
  451.      using std::swprintf;
  452.      using std::swscanf;
  453.      using std::tmpfile;
  454.      using std::tmpnam;
  455.      using std::ungetc;
  456.      using std::ungetwc;
  457.      using std::vfprintf;
  458.      using std::vfscanf;
  459.      using std::vfwprintf;
  460.      using std::vfwscanf;
  461.      using std::vprintf;
  462.      using std::vscanf;
  463.      using std::vsnprintf;
  464.      using std::vsnwprintf;
  465.      using std::vsprintf;
  466.      using std::vsscanf;
  467.      using std::vswprintf;
  468.      using std::vswscanf;
  469.      using std::vwprintf;
  470.      using std::vwscanf;
  471.      using std::wprintf;
  472.      using std::wscanf;
  473.  
  474. #if !defined(__STDC__)
  475.      using std::_snprintf;
  476.      using std::_snwprintf;
  477.      using std::_vsnprintf;
  478.      using std::_vsnwprintf;
  479.      using std::fcloseall;
  480.      using std::fdopen;
  481.      using std::fgetchar;
  482.      using std::fileno;
  483.      using std::flushall;
  484.      using std::fputchar;
  485.      using std::getw;
  486.      using std::putw;
  487.      using std::rmtmp;
  488.      using std::sopen;
  489.      using std::tempnam;
  490.      using std::unlink;
  491. #endif // !__STDC__
  492.  
  493. #endif /* __USING_CNAME__ */
  494.