Prototype __gen_tempname and __path_search, not __stdio_gen_tempname.
[kopensolaris-gnu/glibc.git] / libio / stdio.h
1 /* Define ISO C stdio on top of C++ iostreams.
2    Copyright (C) 1991, 94, 95, 96, 97, 98 Free Software Foundation, Inc.
3
4    The GNU C Library is free software; you can redistribute it and/or
5    modify it under the terms of the GNU Library General Public License as
6    published by the Free Software Foundation; either version 2 of the
7    License, or (at your option) any later version.
8
9    The GNU C Library is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    Library General Public License for more details.
13
14    You should have received a copy of the GNU Library General Public
15    License along with the GNU C Library; see the file COPYING.LIB.  If not,
16    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17    Boston, MA 02111-1307, USA.  */
18
19 /*
20  *      ISO C Standard: 4.9 INPUT/OUTPUT        <stdio.h>
21  */
22
23 #ifndef _STDIO_H
24
25 #ifndef __need_FILE
26 # define _STDIO_H       1
27 # include <features.h>
28
29 __BEGIN_DECLS
30
31 # define __need_size_t
32 # define __need_NULL
33 # include <stddef.h>
34
35 # ifndef __USE_XOPEN
36 #  define __need___va_list
37 # endif
38 # include <stdarg.h>
39
40 # include <bits/types.h>
41 #endif /* Don't need FILE.  */
42 #undef  __need_FILE
43
44
45 #ifndef __FILE_defined
46
47 /* The opaque type of streams.  */
48 typedef struct _IO_FILE FILE;
49
50 # define __FILE_defined 1
51 #endif /* FILE not defined.  */
52
53
54 #ifdef  _STDIO_H
55 #define _STDIO_USES_IOSTREAM
56
57 #include <libio.h>
58
59 #ifdef __cplusplus
60 # define __STDIO_INLINE inline
61 #else
62 # define __STDIO_INLINE extern __inline
63 #endif
64
65 /* The type of the second argument to `fgetpos' and `fsetpos'.  */
66 #ifndef __USE_FILE_OFFSET64
67 typedef _G_fpos_t fpos_t;
68 #else
69 typedef _G_fpos64_t fpos_t;
70 #endif
71 #ifdef __USE_LARGEFILE64
72 typedef _G_fpos64_t fpos64_t;
73 #endif
74
75 /* Generate a unique file name (and possibly open it).  */
76 extern int __path_search __P ((char *__tmpl, size_t __tmpl_len,
77                                __const char *__dir,
78                                __const char *__pfx));
79
80 extern int __gen_tempname __P ((char *__tmpl, int __openit, int __large_file));
81
82 /* Print out MESSAGE on the error output and abort.  */
83 extern void __libc_fatal __P ((__const char *__message))
84      __attribute__ ((__noreturn__));
85
86
87 /* The possibilities for the third argument to `setvbuf'.  */
88 #define _IOFBF 0                /* Fully buffered.  */
89 #define _IOLBF 1                /* Line buffered.  */
90 #define _IONBF 2                /* No buffering.  */
91
92
93 /* Default buffer size.  */
94 #ifndef BUFSIZ
95 # define BUFSIZ _IO_BUFSIZ
96 #endif
97
98
99 /* End of file character.
100    Some things throughout the library rely on this being -1.  */
101 #ifndef EOF
102 # define EOF (-1)
103 #endif
104
105
106 /* The possibilities for the third argument to `fseek'.
107    These values should not be changed.  */
108 #define SEEK_SET        0       /* Seek from beginning of file.  */
109 #define SEEK_CUR        1       /* Seek from current position.  */
110 #define SEEK_END        2       /* Seek from end of file.  */
111
112
113 #if defined __USE_SVID || defined __USE_XOPEN
114 /* Default path prefix for `tempnam' and `tmpnam'.  */
115 # define P_tmpdir       "/tmp"
116 #endif
117
118
119 /* Get the values:
120    L_tmpnam     How long an array of chars must be to be passed to `tmpnam'.
121    TMP_MAX      The minimum number of unique filenames generated by tmpnam
122                 (and tempnam when it uses tmpnam's name space),
123                 or tempnam (the two are separate).
124    L_ctermid    How long an array to pass to `ctermid'.
125    L_cuserid    How long an array to pass to `cuserid'.
126    FOPEN_MAX    Minimum number of files that can be open at once.
127    FILENAME_MAX Maximum length of a filename.  */
128 #include <bits/stdio_lim.h>
129
130
131 /* Standard streams.  */
132 extern FILE *stdin;             /* Standard input stream.  */
133 extern FILE *stdout;            /* Standard output stream.  */
134 extern FILE *stderr;            /* Standard error output stream.  */
135
136
137 /* Remove file FILENAME.  */
138 extern int remove __P ((__const char *__filename));
139 /* Rename file OLD to NEW.  */
140 extern int rename __P ((__const char *__old, __const char *__new));
141
142
143 /* Create a temporary file and open it read/write.  */
144 #ifndef __USE_FILE_OFFSET64
145 extern FILE *tmpfile __P ((void));
146 #else
147 # ifdef __REDIRECT
148 extern FILE *__REDIRECT (tmpfile, __P ((void)), tmpfile64);
149 # else
150 #  define tmpfile tmpfile64
151 # endif
152 #endif
153 #ifdef __USE_LARGEFILE64
154 extern FILE *tmpfile64 __P ((void));
155 #endif
156 /* Generate a temporary filename.  */
157 extern char *tmpnam __P ((char *__s));
158
159 #ifdef __USE_MISC
160 /* This is the reentrant variant of `tmpnam'.  The only difference is
161    that it does not allow S to be NULL.  */
162 extern char *tmpnam_r __P ((char *__s));
163 #endif
164
165
166 #if defined __USE_SVID || defined __USE_XOPEN
167 /* Generate a unique temporary filename using up to five characters of PFX
168    if it is not NULL.  The directory to put this file in is searched for
169    as follows: First the environment variable "TMPDIR" is checked.
170    If it contains the name of a writable directory, that directory is used.
171    If not and if DIR is not NULL, that value is checked.  If that fails,
172    P_tmpdir is tried and finally "/tmp".  The storage for the filename
173    is allocated by `malloc'.  */
174 extern char *tempnam __P ((__const char *__dir, __const char *__pfx));
175 #endif
176
177
178 /* Close STREAM.  */
179 extern int fclose __P ((FILE *__stream));
180 /* Flush STREAM, or all streams if STREAM is NULL.  */
181 extern int fflush __P ((FILE *__stream));
182
183 #ifdef __USE_MISC
184 /* Faster versions when locking is not required.  */
185 extern int fflush_unlocked __P ((FILE *__stream));
186 #endif
187
188 #ifdef __USE_GNU
189 /* Close all streams.  */
190 extern int __fcloseall __P ((void));
191 extern int fcloseall __P ((void));
192 #endif
193
194
195 #ifndef __USE_FILE_OFFSET64
196 /* Open a file and create a new stream for it.  */
197 extern FILE *fopen __P ((__const char *__restrict __filename,
198                          __const char *__restrict __modes));
199 /* Open a file, replacing an existing stream with it. */
200 extern FILE *freopen __P ((__const char *__restrict __filename,
201                            __const char *__restrict __modes,
202                            FILE *__restrict __stream));
203 #else
204 # ifdef __REDIRECT
205 extern FILE *__REDIRECT (fopen, __P ((__const char *__restrict __filename,
206                                    __const char *__restrict __modes)),
207                          fopen64);
208 extern FILE *__REDIRECT (freopen, __P ((__const char *__restrict __filename,
209                                         __const char *__restrict __modes,
210                                         FILE *__restrict __stream)),
211                          freopen64);
212 # else
213 #  define fopen fopen64
214 #  define freopen freopen64
215 # endif
216 #endif
217 #ifdef __USE_LARGEFILE64
218 extern FILE *fopen64 __P ((__const char *__restrict __filename,
219                            __const char *__restrict __modes));
220 extern FILE *freopen64 __P ((__const char *__restrict __filename,
221                              __const char *__restrict __modes,
222                              FILE *__restrict __stream));
223 #endif
224
225 #ifdef  __USE_POSIX
226 /* Create a new stream that refers to an existing system file descriptor.  */
227 extern FILE *fdopen __P ((int __fd, __const char *__modes));
228 #endif
229
230 #ifdef  __USE_GNU
231 /* Create a new stream that refers to the given magic cookie,
232    and uses the given functions for input and output.  */
233 extern FILE *fopencookie __P ((void *__magic_cookie, __const char *__modes,
234                                _IO_cookie_io_functions_t __io_funcs));
235
236 /* Open a stream that writes into a malloc'd buffer that is expanded as
237    necessary.  *BUFLOC and *SIZELOC are updated with the buffer's location
238    and the number of characters written on fflush or fclose.  */
239 extern FILE *open_memstream __P ((char **__bufloc, size_t *__sizeloc));
240 #endif
241
242
243 /* If BUF is NULL, make STREAM unbuffered.
244    Else make it use buffer BUF, of size BUFSIZ.  */
245 extern void setbuf __P ((FILE *__restrict __stream, char *__restrict __buf));
246 /* Make STREAM use buffering mode MODE.
247    If BUF is not NULL, use N bytes of it for buffering;
248    else allocate an internal buffer N bytes long.  */
249 extern int setvbuf __P ((FILE *__restrict __stream, char *__restrict __buf,
250                          int __modes, size_t __n));
251
252 #ifdef  __USE_BSD
253 /* If BUF is NULL, make STREAM unbuffered.
254    Else make it use SIZE bytes of BUF for buffering.  */
255 extern void setbuffer __P ((FILE *__stream, char *__buf, size_t __size));
256
257 /* Make STREAM line-buffered.  */
258 extern void setlinebuf __P ((FILE *__stream));
259 #endif
260
261
262 /* Write formatted output to STREAM.  */
263 extern int fprintf __P ((FILE *__restrict __stream,
264                          __const char *__restrict __format, ...));
265 /* Write formatted output to stdout.  */
266 extern int printf __P ((__const char *__restrict __format, ...));
267 /* Write formatted output to S.  */
268 extern int sprintf __P ((char *__restrict __s,
269                          __const char *__restrict __format, ...));
270
271 /* Write formatted output to S from argument list ARG.  */
272 extern int vfprintf __P ((FILE *__restrict __s,
273                           __const char *__restrict __format,
274                           _G_va_list __arg));
275 /* Write formatted output to stdout from argument list ARG.  */
276 extern int vprintf __P ((__const char *__restrict __format,
277                          _G_va_list __arg));
278 /* Write formatted output to S from argument list ARG.  */
279 extern int vsprintf __P ((char *__restrict __s,
280                           __const char *__restrict __format,
281                           _G_va_list __arg));
282
283 #ifdef  __OPTIMIZE__
284 __STDIO_INLINE int
285 vprintf (__const char *__restrict __fmt, _G_va_list __arg)
286 {
287   return vfprintf (stdout, __fmt, __arg);
288 }
289 #endif /* Optimizing.  */
290
291 #if defined __USE_BSD || defined __USE_ISOC9X || defined __USE_UNIX98
292 /* Maximum chars of output to write in MAXLEN.  */
293 extern int __snprintf __P ((char *__restrict __s, size_t __maxlen,
294                             __const char *__restrict __format, ...))
295      __attribute__ ((__format__ (__printf__, 3, 4)));
296 extern int snprintf __P ((char *__restrict __s, size_t __maxlen,
297                           __const char *__restrict __format, ...))
298      __attribute__ ((__format__ (__printf__, 3, 4)));
299
300 extern int __vsnprintf __P ((char *__restrict __s, size_t __maxlen,
301                              __const char *__restrict __format,
302                              _G_va_list __arg))
303      __attribute__ ((__format__ (__printf__, 3, 0)));
304 extern int vsnprintf __P ((char *__restrict __s, size_t __maxlen,
305                            __const char *__restrict __format,
306                            _G_va_list __arg))
307      __attribute__ ((__format__ (__printf__, 3, 0)));
308 #endif
309
310 #ifdef __USE_GNU
311 /* Write formatted output to a string dynamically allocated with `malloc'.
312    Store the address of the string in *PTR.  */
313 extern int vasprintf __P ((char **__restrict __ptr,
314                            __const char *__restrict __f, _G_va_list __arg))
315      __attribute__ ((__format__ (__printf__, 2, 0)));
316 extern int __asprintf __P ((char **__restrict __ptr,
317                             __const char *__restrict __fmt, ...))
318      __attribute__ ((__format__ (__printf__, 2, 3)));
319 extern int asprintf __P ((char **__restrict __ptr,
320                           __const char *__restrict __fmt, ...))
321      __attribute__ ((__format__ (__printf__, 2, 3)));
322
323 /* Write formatted output to a file descriptor.  */
324 extern int vdprintf __P ((int __fd, __const char *__restrict __fmt,
325                           _G_va_list __arg))
326      __attribute__ ((__format__ (__printf__, 2, 0)));
327 extern int dprintf __P ((int __fd, __const char *__restrict __fmt, ...))
328      __attribute__ ((__format__ (__printf__, 2, 3)));
329 #endif
330
331
332 /* Read formatted input from STREAM.  */
333 extern int fscanf __P ((FILE *__restrict __stream,
334                         __const char *__restrict __format, ...));
335 /* Read formatted input from stdin.  */
336 extern int scanf __P ((__const char *__restrict __format, ...));
337 /* Read formatted input from S.  */
338 extern int sscanf __P ((__const char *__restrict __s,
339                         __const char *__restrict __format, ...));
340
341 #ifdef  __USE_GNU
342 /* Read formatted input from S into argument list ARG.  */
343 extern int __vfscanf __P ((FILE *__restrict __s,
344                            __const char *__restrict __format,
345                            _G_va_list __arg))
346      __attribute__ ((__format__ (__scanf__, 2, 0)));
347 extern int vfscanf __P ((FILE *__restrict __s,
348                          __const char *__restrict __format,
349                          _G_va_list __arg))
350      __attribute__ ((__format__ (__scanf__, 2, 0)));
351
352 /* Read formatted input from stdin into argument list ARG.  */
353 extern int __vscanf __P ((__const char *__restrict __format,
354                           _G_va_list __arg))
355      __attribute__ ((__format__ (__scanf__, 1, 0)));
356 extern int vscanf __P ((__const char *__restrict __format, _G_va_list __arg))
357      __attribute__ ((__format__ (__scanf__, 1, 0)));
358
359 /* Read formatted input from S into argument list ARG.  */
360 extern int __vsscanf __P ((__const char *__restrict __s,
361                            __const char *__restrict __format,
362                            _G_va_list __arg))
363      __attribute__ ((__format__ (__scanf__, 2, 0)));
364 extern int vsscanf __P ((__const char *__restrict __s,
365                          __const char *__restrict __format,
366                          _G_va_list __arg))
367      __attribute__ ((__format__ (__scanf__, 2, 0)));
368 #endif /* Use GNU.  */
369
370
371 /* Read a character from STREAM.  */
372 extern int fgetc __P ((FILE *__stream));
373 extern int getc __P ((FILE *__stream));
374
375 /* Read a character from stdin.  */
376 extern int getchar __P ((void));
377
378 /* The C standard explicitly says this is a macro, so we always do the
379    optimization for it.  */
380 #define getc(_fp) _IO_getc (_fp)
381
382 #ifdef  __OPTIMIZE__
383 __STDIO_INLINE int
384 getchar (void)
385 {
386   return _IO_getc (stdin);
387 }
388 #endif /* Optimizing.  */
389
390 #if defined __USE_POSIX || defined __USE_MISC
391 /* These are defined in POSIX.1:1996.  */
392 extern int getc_unlocked __P ((FILE *__stream));
393 extern int getchar_unlocked __P ((void));
394
395 # ifdef __OPTIMIZE__
396 __STDIO_INLINE int
397 getc_unlocked (FILE *__fp)
398 {
399   return _IO_getc_unlocked (__fp);
400 }
401
402 __STDIO_INLINE int
403 getchar_unlocked (void)
404 {
405   return _IO_getc_unlocked (stdin);
406 }
407 # endif /* Optimizing.  */
408 #endif /* Use POSIX or MISC.  */
409
410
411 /* Write a character to STREAM.  */
412 extern int fputc __P ((int __c, FILE *__stream));
413 extern int putc __P ((int __c, FILE *__stream));
414
415 /* Write a character to stdout.  */
416 extern int putchar __P ((int __c));
417
418 /* The C standard explicitly says this can be a macro,
419    so we always do the optimization for it.  */
420 #define putc(_ch, _fp) _IO_putc (_ch, _fp)
421
422 #ifdef __OPTIMIZE__
423 __STDIO_INLINE int
424 putchar (int __c)
425 {
426   return _IO_putc (__c, stdout);
427 }
428 #endif
429
430 #ifdef __USE_MISC
431 /* Faster version when locking is not necessary.  */
432 extern int fputc_unlocked __P ((int __c, FILE *__stream));
433
434 # ifdef __OPTIMIZE__
435 __STDIO_INLINE int
436 fputc_unlocked (int __c, FILE *__stream)
437 {
438   return _IO_putc_unlocked (__c, __stream);
439 }
440 # endif /* Optimizing.  */
441 #endif /* Use MISC.  */
442
443 #if defined __USE_POSIX || defined __USE_MISC
444 /* These are defined in POSIX.1:1996.  */
445 extern int putc_unlocked __P ((int __c, FILE *__stream));
446 extern int putchar_unlocked __P ((int __c));
447
448 # ifdef __OPTIMIZE__
449 __STDIO_INLINE int
450 putc_unlocked (int __c, FILE *__stream)
451 {
452   return _IO_putc_unlocked (__c, __stream);
453 }
454
455 __STDIO_INLINE int
456 putchar_unlocked (int __c)
457 {
458   return _IO_putc_unlocked (__c, stdout);
459 }
460 # endif /* Optimizing.  */
461 #endif /* Use POSIX or MISc.  */
462
463
464 #if defined __USE_SVID || defined __USE_MISC || defined __USE_XOPEN
465 /* Get a word (int) from STREAM.  */
466 extern int getw __P ((FILE *__stream));
467
468 /* Write a word (int) to STREAM.  */
469 extern int putw __P ((int __w, FILE *__stream));
470 #endif
471
472
473 /* Get a newline-terminated string of finite length from STREAM.  */
474 extern char *fgets __P ((char *__restrict __s, int __n,
475                          FILE *__restrict __stream));
476
477 #ifdef __USE_GNU
478 /* This function does the same as `fgets' but does not lock the stream.  */
479 extern char *fgets_unlocked __P ((char *__restrict __s, int __n,
480                                   FILE *__restrict __stream));
481 #endif
482
483 /* Get a newline-terminated string from stdin, removing the newline.
484    DO NOT USE THIS FUNCTION!!  There is no limit on how much it will read.  */
485 extern char *gets __P ((char *__s));
486
487
488 #ifdef  __USE_GNU
489 /* Read up to (and including) a DELIMITER from STREAM into *LINEPTR
490    (and null-terminate it). *LINEPTR is a pointer returned from malloc (or
491    NULL), pointing to *N characters of space.  It is realloc'd as
492    necessary.  Returns the number of characters read (not including the
493    null terminator), or -1 on error or EOF.  */
494 _IO_ssize_t __getdelim __P ((char **__lineptr, size_t *__n,
495                              int __delimiter, FILE *__stream));
496 _IO_ssize_t getdelim __P ((char **__lineptr, size_t *__n,
497                            int __delimiter, FILE *__stream));
498
499 /* Like `getdelim', but reads up to a newline.  */
500 _IO_ssize_t __getline __P ((char **__lineptr, size_t *__n, FILE *__stream));
501 _IO_ssize_t getline __P ((char **__lineptr, size_t *__n, FILE *__stream));
502
503 # ifdef __OPTIMIZE__
504 __STDIO_INLINE _IO_ssize_t
505 getline (char **__lineptr, size_t *__n, FILE *__stream)
506 {
507   return __getdelim (__lineptr, __n, '\n', __stream);
508 }
509 # endif /* Optimizing.  */
510 #endif
511
512
513 /* Write a string to STREAM.  */
514 extern int fputs __P ((__const char *__restrict __s,
515                        FILE *__restrict __stream));
516
517 #ifdef __USE_GNU
518 /* This function does the same as `fputs' but does not lock the stream.  */
519 extern int fputs_unlocked __P ((__const char *__restrict __s,
520                                 FILE *__restrict __stream));
521 #endif
522
523 /* Write a string, followed by a newline, to stdout.  */
524 extern int puts __P ((__const char *__s));
525
526
527 /* Push a character back onto the input buffer of STREAM.  */
528 extern int ungetc __P ((int __c, FILE *__stream));
529
530
531 /* Read chunks of generic data from STREAM.  */
532 extern size_t fread __P ((void *__restrict __ptr, size_t __size,
533                           size_t __n, FILE *__restrict __stream));
534 /* Write chunks of generic data to STREAM.  */
535 extern size_t fwrite __P ((__const void *__restrict __ptr, size_t __size,
536                            size_t __n, FILE *__restrict __s));
537
538 #ifdef __USE_MISC
539 /* Faster versions when locking is not necessary.  */
540 extern size_t fread_unlocked __P ((void *__restrict __ptr, size_t __size,
541                                    size_t __n, FILE *__restrict __stream));
542 extern size_t fwrite_unlocked __P ((__const void *__restrict __ptr,
543                                     size_t __size, size_t __n,
544                                     FILE *__restrict __stream));
545 #endif
546
547
548 /* Seek to a certain position on STREAM.  */
549 extern int fseek __P ((FILE *__stream, long int __off, int __whence));
550 /* Return the current position of STREAM.  */
551 extern long int ftell __P ((FILE *__stream));
552 /* Rewind to the beginning of STREAM.  */
553 extern void rewind __P ((FILE *__stream));
554
555 #if (defined __USE_LARGEFILE || defined __USE_LARGEFILE64 \
556      || defined __USE_FILE_OFFSET64)
557 /* The Single Unix Specification, Version 2, specifies an alternative,
558    more adequate interface for the two functions above which deal with
559    file offset.  `long int' is not the right type.  These definitions
560    are originally defined in the Large File Support API.  */
561
562 /* Types needed in these functions.  */
563 # ifndef off_t
564 #  ifndef __USE_FILE_OFFSET64
565 typedef __off_t off_t;
566 #  else
567 typedef __off64_t off_t;
568 #  endif
569 #  define off_t off_t
570 # endif
571
572 # if defined __USE_LARGEFILE64 && !defined off64_t
573 typedef __off64_t off64_t;
574 #  define off64_t off64_t
575 # endif
576
577
578 # ifndef __USE_FILE_OFFSET64
579 /* Seek to a certain position on STREAM.  */
580 extern int fseeko __P ((FILE *__stream, __off_t __off, int __whence));
581 /* Return the current position of STREAM.  */
582 extern __off_t ftello __P ((FILE *__stream));
583 /* Get STREAM's position.  */
584 extern int fgetpos __P ((FILE *__restrict __stream,
585                          fpos_t *__restrict __pos));
586 /* Set STREAM's position.  */
587 extern int fsetpos __P ((FILE *__stream, __const fpos_t *__pos));
588 # else
589 # ifdef __REDIRECT
590 extern int __REDIRECT (fseeko,
591                        __P ((FILE *__stream, __off64_t __off, int __whence)),
592                        fseeko64);
593 extern __off64_t __REDIRECT (ftello, __P ((FILE *__stream)), ftello64);
594 extern int __REDIRECT (fgetpos, __P ((FILE *__restrict __stream,
595                                       fpos_t *__restrict __pos)), fgetpos64);
596 extern int __REDIRECT (fsetpos, __P ((FILE *__stream, __const fpos_t *__pos)),
597                        fsetpos64);
598 #  else
599 #   define fseeko fseeko64
600 #   define ftello ftello64
601 #   define fgetpos fgetpos64
602 #   define fsetpos fsetpos64
603 #  endif
604 # endif
605
606 # ifdef __USE_LARGEFILE64
607 extern int fseeko64 __P ((FILE *__stream, __off64_t __off, int __whence));
608 extern __off64_t ftello64 __P ((FILE *__stream));
609 extern int fgetpos64 __P ((FILE *__restrict __stream,
610                            fpos64_t *__restrict __pos));
611 extern int fsetpos64 __P ((FILE *__stream, __const fpos64_t *__pos));
612 # endif
613 #endif
614
615 /* Clear the error and EOF indicators for STREAM.  */
616 extern void clearerr __P ((FILE *__stream));
617 /* Return the EOF indicator for STREAM.  */
618 extern int feof __P ((FILE *__stream));
619 /* Return the error indicator for STREAM.  */
620 extern int ferror __P ((FILE *__stream));
621
622 #ifdef __USE_MISC
623 /* Faster versions when locking is not required.  */
624 extern void clearerr_unlocked __P ((FILE *__stream));
625 extern int feof_unlocked __P ((FILE *__stream));
626 extern int ferror_unlocked __P ((FILE *__stream));
627
628 # ifdef __OPTIMIZE__
629 __STDIO_INLINE int
630 feof_unlocked (FILE *__stream)
631 {
632   return _IO_feof_unlocked (__stream);
633 }
634
635 __STDIO_INLINE int
636 ferror_unlocked (FILE *__stream)
637 {
638   return _IO_ferror_unlocked (__stream);
639 }
640 # endif /* Optimizing.  */
641 #endif
642
643
644 /* Print a message describing the meaning of the value of errno.  */
645 extern void perror __P ((__const char *__s));
646
647 /* These variables normally should not be used directly.  The `strerror'
648    function provides all the needed functionality.  */
649 #ifdef  __USE_BSD
650 extern int sys_nerr;
651 extern __const char *__const sys_errlist[];
652 #endif
653 #ifdef  __USE_GNU
654 extern int _sys_nerr;
655 extern __const char *__const _sys_errlist[];
656 #endif
657
658
659 #ifdef  __USE_POSIX
660 /* Return the system file descriptor for STREAM.  */
661 extern int fileno __P ((FILE *__stream));
662 #endif /* Use POSIX.  */
663
664 #ifdef __USE_MISC
665 /* Faster version when locking is not required.  */
666 extern int fileno_unlocked __P ((FILE *__stream));
667 #endif
668
669
670 #if (defined __USE_POSIX2 || defined __USE_SVID  || defined __USE_BSD || \
671      defined __USE_MISC)
672 /* Create a new stream connected to a pipe running the given command.  */
673 extern FILE *popen __P ((__const char *__command, __const char *__modes));
674
675 /* Close a stream opened by popen and return the status of its child.  */
676 extern int pclose __P ((FILE *__stream));
677 #endif
678
679
680 #ifdef  __USE_POSIX
681 /* Return the name of the controlling terminal.  */
682 extern char *ctermid __P ((char *__s));
683 #endif /* Use POSIX.  */
684
685
686 #ifdef __USE_XOPEN
687 /* Return the name of the current user.  */
688 extern char *cuserid __P ((char *__s));
689 #endif /* Use X/Open.  */
690
691
692 #ifdef  __USE_GNU
693 struct obstack;                 /* See <obstack.h>.  */
694
695 /* Write formatted output to an obstack.  */
696 extern int obstack_printf __P ((struct obstack *__obstack,
697                                 __const char *__format, ...));
698 extern int obstack_vprintf __P ((struct obstack *__obstack,
699                                  __const char *__format,
700                                  _G_va_list __args));
701 #endif /* Use GNU.  */
702
703
704 #if defined __USE_POSIX || defined __USE_MISC
705 /* These are defined in POSIX.1:1996.  */
706
707 /* Acquire ownership of STREAM.  */
708 extern void flockfile __P ((FILE *__stream));
709
710 /* Try to acquire ownership of STREAM but do not block if it is not
711    possible.  */
712 extern int ftrylockfile __P ((FILE *__stream));
713
714 /* Relinquish the ownership granted for STREAM.  */
715 extern void funlockfile __P ((FILE *__stream));
716 #endif /* POSIX || misc */
717
718 #if defined __USE_XOPEN && !defined __USE_GNU
719 /* The X/Open standard requires some functions and variables to be
720    declared here which do not belong into this header.  But we have to
721    follow.  In GNU mode we don't do this nonsense.  */
722
723 /* For more information on these symbols look in <getopt.h>.  */
724 extern char *optarg;
725 extern int optind;
726 extern int opterr;
727 extern int optopt;
728
729 extern int getopt __P ((int __argc, char *__const *__argv,
730                         __const char *__shortopts));
731 #endif
732
733 __END_DECLS
734
735 /* Define helper macro.  */
736 #undef __STDIO_INLINE
737
738 #endif /* <stdio.h> included.  */
739
740 #endif /* !_STDIO_H */