fgetws implementation.
[kopensolaris-gnu/glibc.git] / stdio / stdio.h
1 /* Copyright (C) 1991,92,93,94,95,96,97,98 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
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 #if     !defined(__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 #define __need___va_list
36 #include <stdarg.h>
37 #ifndef __GNUC_VA_LIST
38 #define __gnuc_va_list  __ptr_t
39 #endif
40
41 #include <bits/types.h>
42 #endif /* Don't need FILE.  */
43 #undef  __need_FILE
44
45
46 #ifndef __FILE_defined
47
48 /* The opaque type of streams.  */
49 typedef struct __stdio_file FILE;
50
51 #define __FILE_defined  1
52 #endif /* FILE not defined.  */
53
54
55 #ifdef  _STDIO_H
56
57 /* The type of the second argument to `fgetpos' and `fsetpos'.  */
58 typedef __off_t fpos_t;
59
60 /* The mode of I/O, as given in the MODE argument to fopen, etc.  */
61 typedef struct
62 {
63   unsigned int __read:1;        /* Open for reading.  */
64   unsigned int __write:1;       /* Open for writing.  */
65   unsigned int __append:1;      /* Open for appending.  */
66   unsigned int __binary:1;      /* Opened binary.  */
67   unsigned int __create:1;      /* Create the file.  */
68   unsigned int __exclusive:1;   /* Error if it already exists.  */
69   unsigned int __truncate:1;    /* Truncate the file on opening.  */
70 } __io_mode;
71
72
73 /* Functions to do I/O and file management for a stream.  */
74
75 /* Read NBYTES bytes from COOKIE into a buffer pointed to by BUF.
76    Return number of bytes read.  */
77 typedef __ssize_t __io_read_fn __PMT ((__ptr_t __cookie, char *__buf,
78                                        size_t __nbytes));
79
80 /* Write N bytes pointed to by BUF to COOKIE.  Write all N bytes
81    unless there is an error.  Return number of bytes written, or -1 if
82    there is an error without writing anything.  If the file has been
83    opened for append (__mode.__append set), then set the file pointer
84    to the end of the file and then do the write; if not, just write at
85    the current file pointer.  */
86 typedef __ssize_t __io_write_fn __PMT ((__ptr_t __cookie, __const char *__buf,
87                                       size_t __n));
88
89 /* Move COOKIE's file position to *POS bytes from the
90    beginning of the file (if W is SEEK_SET),
91    the current position (if W is SEEK_CUR),
92    or the end of the file (if W is SEEK_END).
93    Set *POS to the new file position.
94    Returns zero if successful, nonzero if not.  */
95 typedef int __io_seek_fn __PMT ((__ptr_t __cookie, fpos_t *__pos, int __w));
96
97 /* Close COOKIE.  */
98 typedef int __io_close_fn __PMT ((__ptr_t __cookie));
99
100 /* Return the file descriptor associated with COOKIE,
101    or -1 on error.  There need not be any associated file descriptor.  */
102 typedef int __io_fileno_fn __PMT ((__ptr_t __cookie));
103
104 #ifdef __USE_GNU
105 /* User-visible names for the above.  */
106 typedef __io_read_fn cookie_read_function_t;
107 typedef __io_write_fn cookie_write_function_t;
108 typedef __io_seek_fn cookie_seek_function_t;
109 typedef __io_close_fn cookie_close_function_t;
110 typedef __io_fileno_fn cookie_fileno_function_t;
111 #endif
112
113 /* Low level interface, independent of FILE representation.  */
114 #if defined __USE_GNU && !defined _LIBC
115 /* Define the user-visible type, with user-friendly member names.  */
116 typedef struct
117 {
118   __io_read_fn *read;           /* Read bytes.  */
119   __io_write_fn *write;         /* Write bytes.  */
120   __io_seek_fn *seek;           /* Seek/tell file position.  */
121   __io_close_fn *close;         /* Close file.  */
122   __io_fileno_fn *fileno;       /* Return file descriptor.  */
123 } cookie_io_functions_t;
124 /* This name is still used in the prototypes in this file.  */
125 typedef cookie_io_functions_t __io_functions;
126 #else
127 /* Stick to ANSI-safe names.  */
128 typedef struct
129 {
130   __io_read_fn *__read;         /* Read bytes.  */
131   __io_write_fn *__write;       /* Write bytes.  */
132   __io_seek_fn *__seek;         /* Seek/tell file position.  */
133   __io_close_fn *__close;       /* Close file.  */
134   __io_fileno_fn *__fileno;     /* Return file descriptor.  */
135 } __io_functions;
136 #endif
137
138 /* Higher level interface, dependent on FILE representation.  */
139 typedef struct
140 {
141   /* Make room in the input buffer.  */
142   int (*__input) __PMT ((FILE *__stream));
143   /* Make room in the output buffer.  */
144   void (*__output) __PMT ((FILE *__stream, int __c));
145 } __room_functions;
146
147 extern __const __io_functions __default_io_functions;
148 extern __const __room_functions __default_room_functions;
149
150
151 /* Default close function.  */
152 extern __io_close_fn __stdio_close;
153 /* Open FILE with mode M, store cookie in *COOKIEPTR.  */
154 extern int __stdio_open __P ((__const char *__file, __io_mode __m,
155                               __ptr_t *__cookieptr));
156 /* Put out an error message for when stdio needs to die.  */
157 extern void __stdio_errmsg __P ((__const char *__msg, size_t __len));
158
159
160
161 /* For thread safe I/O functions we need a lock in each stream.  We
162    keep the type opaque here.  */
163 struct __stdio_lock;
164
165 /* The FILE structure.  */
166 struct __stdio_file
167 {
168   /* Magic number for validation.  Must be negative in open streams
169      for the glue to Unix stdio getc/putc to work.
170      NOTE: stdio/glue.c has special knowledge of these first four members.  */
171   int __magic;
172 #define _IOMAGIC ((int) 0xfedabeeb)     /* Magic number to fill `__magic'.  */
173 #define _GLUEMAGIC ((int) 0xfeedbabe)   /* Magic for glued Unix streams.  */
174
175   char *__bufp;                 /* Pointer into the buffer.  */
176   char *__get_limit;            /* Reading limit.  */
177   char *__put_limit;            /* Writing limit.  */
178
179   char *__buffer;               /* Base of buffer.  */
180   size_t __bufsize;             /* Size of the buffer.  */
181   __ptr_t __cookie;             /* Magic cookie.  */
182   __io_mode __mode;             /* File access mode.  */
183   __io_functions __io_funcs;    /* I/O functions.  */
184   __room_functions __room_funcs;/* I/O buffer room functions.  */
185   fpos_t __offset;              /* Current file position.  */
186   fpos_t __target;              /* Target file position.  */
187   FILE *__next;                 /* Next FILE in the linked list.  */
188   char *__pushback_bufp;        /* Old bufp if char pushed back.  */
189   unsigned char __pushback;     /* Pushed-back character.  */
190   unsigned int __pushed_back:1; /* A char has been pushed back.  */
191   unsigned int __eof:1;         /* End of file encountered.  */
192   unsigned int __error:1;       /* Error encountered.  */
193   unsigned int __userbuf:1;     /* Buffer from user (should not be freed).  */
194   unsigned int __linebuf:1;     /* Flush on newline.  */
195   unsigned int __linebuf_active:1; /* put_limit is not really in use.  */
196   unsigned int __seen:1;        /* This stream has been seen.  */
197   unsigned int __ispipe:1;      /* Nonzero if opened by popen.  */
198   struct __stdio_lock *__lock;  /* Pointer to associated lock.  */
199 };
200
201
202 /* All macros used internally by other macros here and by stdio functions begin
203    with `__'.  All of these may evaluate their arguments more than once.  */
204
205
206 /* Nonzero if STREAM is a valid stream.
207    STREAM must be a modifiable lvalue (wow, I got to use that term).
208    See stdio/glue.c for what the confusing bit is about.  */
209 #define __validfp(stream)                                                     \
210   (stream != NULL &&                                                          \
211    ({ if (stream->__magic == _GLUEMAGIC)                                      \
212         stream = *((struct { int __magic; FILE **__p; } *) stream)->__p;      \
213       stream->__magic == _IOMAGIC; }))
214
215 /* Clear the error and EOF indicators of STREAM.  */
216 #define __clearerr(stream)      ((stream)->__error = (stream)->__eof = 0)
217
218 /* Nuke STREAM, making it unusable but available for reuse.  */
219 extern void __invalidate __P ((FILE *__stream));
220
221 /* Make sure STREAM->__offset and STREAM->__target are initialized.
222    Returns 0 if successful, or EOF on
223    error (but doesn't set STREAM->__error).  */
224 extern int __stdio_check_offset __P ((FILE *__stream));
225
226
227 /* The possibilities for the third argument to `setvbuf'.  */
228 #define _IOFBF  0x1             /* Full buffering.  */
229 #define _IOLBF  0x2             /* Line buffering.  */
230 #define _IONBF  0x4             /* No buffering.  */
231
232
233 /* Default buffer size.  */
234 #define BUFSIZ  1024
235
236
237 /* End of file character.
238    Some things throughout the library rely on this being -1.  */
239 #define EOF     (-1)
240
241
242 /* The possibilities for the third argument to `fseek'.
243    These values should not be changed.  */
244 #define SEEK_SET        0       /* Seek from beginning of file.  */
245 #define SEEK_CUR        1       /* Seek from current position.  */
246 #define SEEK_END        2       /* Seek from end of file.  */
247
248
249 #ifdef  __USE_SVID
250 /* Default path prefix for `tempnam' and `tmpnam'.  */
251 #define P_tmpdir        "/usr/tmp"
252 #endif
253
254
255 /* Get the values:
256    L_tmpnam     How long an array of chars must be to be passed to `tmpnam'.
257    TMP_MAX      The minimum number of unique filenames generated by tmpnam
258                 (and tempnam when it uses tmpnam's name space),
259                 or tempnam (the two are separate).
260    L_ctermid    How long an array to pass to `ctermid'.
261    L_cuserid    How long an array to pass to `cuserid'.
262    FOPEN_MAX    Minimum number of files that can be open at once.
263    FILENAME_MAX Maximum length of a filename.  */
264 #include <bits/stdio_lim.h>
265
266
267 /* All the known streams are in a linked list
268    linked by the `next' field of the FILE structure.  */
269 extern FILE *__stdio_head;      /* Head of the list.  */
270
271 /* Standard streams.  */
272 extern FILE *stdin, *stdout, *stderr;
273 #ifdef __STRICT_ANSI__
274 /* ANSI says these are macros; satisfy pedants.  */
275 #define stdin   stdin
276 #define stdout  stdout
277 #define stderr  stderr
278 #endif
279
280
281 /* Remove file FILENAME.  */
282 extern int remove __P ((__const char *__filename));
283 /* Rename file OLD to NEW.  */
284 extern int rename __P ((__const char *__old, __const char *__new));
285
286
287 /* Create a temporary file and open it read/write.  */
288 extern FILE *tmpfile __P ((void));
289 #ifdef __USE_LARGEFILE64
290 extern FILE *tmpfile64 __P ((void));
291 #endif
292 /* Generate a temporary filename.  */
293 extern char *tmpnam __P ((char *__s));
294
295 #ifdef __USE_REENTRANT
296 /* This is the reentrant variant of `tmpnam'.  The only difference is
297    that it does not allow S to be NULL.  */
298 extern char *tmpnam_r __P ((char *__s));
299 #endif
300
301
302 #if defined __USE_SVID || defined __USE_XOPEN
303 /* Generate a unique temporary filename using up to five characters of PFX
304    if it is not NULL.  The directory to put this file in is searched for
305    as follows: First the environment variable "TMPDIR" is checked.
306    If it contains the name of a writable directory, that directory is used.
307    If not and if DIR is not NULL, that value is checked.  If that fails,
308    P_tmpdir is tried and finally "/tmp".  The storage for the filename
309    is allocated by `malloc'.  */
310 extern char *tempnam __P ((__const char *__dir, __const char *__pfx));
311 #endif
312
313
314 /* This performs actual output when necessary, flushing
315    STREAM's buffer and optionally writing another character.  */
316 extern int __flshfp __P ((FILE *__stream, int __c));
317
318
319 /* Close STREAM.  */
320 extern int fclose __P ((FILE *__stream));
321 /* Flush STREAM, or all streams if STREAM is NULL.  */
322 extern int fflush __P ((FILE *__stream));
323
324 #ifdef __USE_MISC
325 /* Faster versions when locking is not required.  */
326 extern int fflush_unlocked __P ((FILE *__stream));
327 #endif
328
329 #ifdef __USE_GNU
330 /* Close all streams.  */
331 extern int __fcloseall __P ((void));
332 extern int fcloseall __P ((void));
333 #endif
334
335
336 /* Open a file and create a new stream for it.  */
337 extern FILE *fopen __P ((__const char *__filename, __const char *__modes));
338 /* Open a file, replacing an existing stream with it. */
339 extern FILE *freopen __P ((__const char *__restrict __filename,
340                            __const char *__restrict __modes,
341                            FILE *__restrict __stream));
342
343 /* Return a new, zeroed, stream.
344    You must set its cookie and io_mode.
345    The first operation will give it a buffer unless you do.
346    It will also give it the default functions unless you set the `seen' flag.
347    The offset is set to -1, meaning it will be determined by doing a
348    stationary seek.  You can set it to avoid the initial tell call.
349    The target is set to -1, meaning it will be set to the offset
350    before the target is needed.
351    Returns NULL if a stream can't be created.  */
352 extern FILE *__newstream __P ((void));
353
354 #ifdef  __USE_POSIX
355 /* Create a new stream that refers to an existing system file descriptor.  */
356 extern FILE *__fdopen __P ((int __fd, __const char *__modes));
357 extern FILE *fdopen __P ((int __fd, __const char *__modes));
358 #endif
359
360 #ifdef  __USE_GNU
361 /* Create a new stream that refers to the given magic cookie,
362    and uses the given functions for input and output.  */
363 extern FILE *fopencookie __P ((__ptr_t __magic_cookie, __const char *__modes,
364                                __io_functions __io_funcs));
365
366 /* Create a new stream that refers to a memory buffer.  */
367 extern FILE *fmemopen __P ((__ptr_t __s, size_t __len, __const char *__modes));
368
369 /* Open a stream that writes into a malloc'd buffer that is expanded as
370    necessary.  *BUFLOC and *SIZELOC are updated with the buffer's location
371    and the number of characters written on fflush or fclose.  */
372 extern FILE *open_memstream __P ((char **__bufloc, size_t *__sizeloc));
373 #endif
374
375
376 /* If BUF is NULL, make STREAM unbuffered.
377    Else make it use buffer BUF, of size BUFSIZ.  */
378 extern void setbuf __P ((FILE *__restrict __stream, char *__restrict __buf));
379 /* Make STREAM use buffering mode MODE.
380    If BUF is not NULL, use N bytes of it for buffering;
381    else allocate an internal buffer N bytes long.  */
382 extern int setvbuf __P ((FILE *__restrict __stream, char *__restrict __buf,
383                          int __modes, size_t __n));
384
385 #ifdef  __USE_BSD
386 /* If BUF is NULL, make STREAM unbuffered.
387    Else make it use SIZE bytes of BUF for buffering.  */
388 extern void setbuffer __P ((FILE *__stream, char *__buf, size_t __size));
389
390 /* Make STREAM line-buffered.  */
391 extern void setlinebuf __P ((FILE *__stream));
392 #endif
393
394
395 /* Write formatted output to STREAM.  */
396 extern int fprintf __P ((FILE *__restrict __stream,
397                          __const char *__restrict __format, ...));
398 /* Write formatted output to stdout.  */
399 extern int printf __P ((__const char *__restrict __format, ...));
400 /* Write formatted output to S.  */
401 extern int sprintf __P ((char *__restrict __s,
402                          __const char *__restrict __format, ...));
403
404 /* Write formatted output to S from argument list ARG.  */
405 extern int vfprintf __P ((FILE *__restrict __s,
406                           __const char *__restrict __format,
407                           __gnuc_va_list __arg));
408 /* Write formatted output to stdout from argument list ARG.  */
409 extern int vprintf __P ((__const char *__restrict __format,
410                          __gnuc_va_list __arg));
411 /* Write formatted output to S from argument list ARG.  */
412 extern int vsprintf __P ((char *__restrict __s,
413                           __const char *__restrict __format,
414                           __gnuc_va_list __arg));
415
416 #ifdef  __OPTIMIZE__
417 extern __inline int
418 vprintf (const char *__restrict __fmt, __gnuc_va_list __arg) __THROW
419 {
420   return vfprintf (stdout, __fmt, __arg);
421 }
422 #endif /* Optimizing.  */
423
424 #if defined __USE_BSD || defined __USE_ISOC9X
425 /* Maximum chars of output to write in MAXLEN.  */
426 extern int __snprintf __P ((char *__s, size_t __maxlen,
427                             __const char *__format, ...))
428      __attribute__ ((__format__ (__printf__, 3, 4)));
429 extern int snprintf __P ((char *__s, size_t __maxlen,
430                           __const char *__format, ...))
431      __attribute__ ((__format__ (__printf__, 3, 4)));
432
433 extern int __vsnprintf __P ((char *__s, size_t __maxlen,
434                              __const char *__format, __gnuc_va_list __arg))
435      __attribute__ ((__format__ (__printf__, 3, 0)));
436 extern int vsnprintf __P ((char *__s, size_t __maxlen,
437                            __const char *__format, __gnuc_va_list __arg))
438      __attribute__ ((__format__ (__printf__, 3, 0)));
439 #endif
440
441 #ifdef __USE_GNU
442 /* Write formatted output to a string dynamically allocated with `malloc'.
443    Store the address of the string in *PTR.  */
444 extern int vasprintf __P ((char **__restrict __ptr,
445                            __const char *__restrict __f, __gnuc_va_list __arg))
446      __attribute__ ((__format__ (__printf__, 2, 0)));
447 extern int __asprintf __P ((char **__restrict __ptr,
448                             __const char *__restrict __fmt, ...))
449      __attribute__ ((__format__ (__printf__, 2, 3)));
450 extern int asprintf __P ((char **__restrict __ptr,
451                           __const char *__restrict __fmt, ...))
452      __attribute__ ((__format__ (__printf__, 2, 3)));
453
454 /* Write formatted output to a file descriptor.  */
455 extern int vdprintf __P ((int __fd, __const char *__restrict __fmt,
456                           __gnuc_va_list __arg))
457      __attribute__ ((__format__ (__printf__, 2, 0)));
458 extern int dprintf __P ((int __fd, __const char *__restrict __fmt, ...))
459      __attribute__ ((__format__ (__printf__, 2, 3)));
460 #endif
461
462
463 /* Read formatted input from STREAM.  */
464 extern int fscanf __P ((FILE *__restrict __stream,
465                         __const char *__restrict __format, ...));
466 /* Read formatted input from stdin.  */
467 extern int scanf __P ((__const char *__restrict __format, ...));
468 /* Read formatted input from S.  */
469 extern int sscanf __P ((__const char *__restrict __s,
470                         __const char *__restrict __format, ...));
471
472 #ifdef  __USE_ISOC9X
473 /* Read formatted input from S into argument list ARG.  */
474 extern int __vfscanf __P ((FILE *__s, __const char *__format,
475                            __gnuc_va_list __arg));
476 extern int vfscanf __P ((FILE *__s, __const char *__format,
477                          __gnuc_va_list __arg));
478
479 /* Read formatted input from stdin into argument list ARG.  */
480 extern int __vscanf __P ((__const char *__format, __gnuc_va_list __arg));
481 extern int vscanf __P ((__const char *__format, __gnuc_va_list __arg));
482
483 /* Read formatted input from S into argument list ARG.  */
484 extern int __vsscanf __P ((__const char *__s, __const char *__format,
485                            __gnuc_va_list __arg));
486 extern int vsscanf __P ((__const char *__s, __const char *__format,
487                          __gnuc_va_list __arg));
488
489
490 #ifdef  __OPTIMIZE__
491 extern __inline int
492 vfscanf (FILE *__s, const char *__fmt, __gnuc_va_list __arg) __THROW
493 {
494   return __vfscanf (__s, __fmt, __arg);
495 }
496 extern __inline int
497 vscanf (const char *__fmt, __gnuc_va_list __arg) __THROW
498 {
499   return __vfscanf (stdin, __fmt, __arg);
500 }
501 extern __inline int
502 vsscanf (const char *__s, const char *__fmt, __gnuc_va_list __arg) __THROW
503 {
504   return __vsscanf (__s, __fmt, __arg);
505 }
506 #endif /* Optimizing.  */
507 #endif /* Use ISO C9x.  */
508
509
510 /* This does actual reading when necessary, filling STREAM's
511    buffer and returning the first character in it.  */
512 extern int __fillbf __P ((FILE *__stream));
513
514
515 /* Read a character from STREAM.  */
516 extern int fgetc __P ((FILE *__stream));
517 extern int getc __P ((FILE *__stream));
518
519 /* Read a character from stdin.  */
520 extern int getchar __P ((void));
521
522 /* The C standard explicitly says this can
523    re-evaluate its argument, so it does. */
524 #define __getc(stream)                                                        \
525   ((stream)->__bufp < (stream)->__get_limit ?                                 \
526    (int) ((unsigned char) *(stream)->__bufp++) : __fillbf(stream))
527
528 /* The C standard explicitly says this is a macro,
529    so we always do the optimization for it.  */
530 #define getc(stream)    __getc(stream)
531
532 #ifdef  __OPTIMIZE__
533 extern __inline int
534 getchar (void) __THROW
535 {
536   return __getc (stdin);
537 }
538 #endif /* Optimizing.  */
539
540 #if defined __USE_POSIX || defined __USE_MISC
541 /* These are defined in POSIX.1:1996.  */
542 extern int getc_unlocked __P ((FILE *__stream));
543 extern int getchar_unlocked __P ((void));
544
545 # ifdef __OPTIMIZE__
546 extern __inline int
547 getc_unlocked (FILE *__stream) __THROW
548 {
549   return __getc (__stream);
550 }
551
552 extern __inline int
553 getchar_unlocked (void) __THROW
554 {
555   return __getc (stdin);
556 }
557 # endif /* Optimizing.  */
558 #endif /* Use POSIX or MISC.  */
559
560
561 /* Write a character to STREAM.  */
562 extern int fputc __P ((int __c, FILE *__stream));
563 extern int putc __P ((int __c, FILE *__stream));
564
565 /* Write a character to stdout.  */
566 extern int putchar __P ((int __c));
567
568
569 /* The C standard explicitly says this can
570    re-evaluate its arguments, so it does.  */
571 #define __putc(c, stream)                                                     \
572   ((stream)->__bufp < (stream)->__put_limit ?                                 \
573    (int) (unsigned char) (*(stream)->__bufp++ = (unsigned char) (c)) :        \
574    __flshfp ((stream), (unsigned char) (c)))
575
576 /* The C standard explicitly says this can be a macro,
577    so we always do the optimization for it.  */
578 #define putc(c, stream) __putc ((c), (stream))
579
580 #ifdef __OPTIMIZE__
581 extern __inline int
582 putchar (int __c) __THROW
583 {
584   return __putc (__c, stdout);
585 }
586 #endif
587
588 #ifdef __USE_MISC
589 /* Faster version when locking is not necessary.  */
590 extern int fputc_unlocked __P ((int __c, FILE *__stream));
591
592 # ifdef __OPTIMIZE__
593 extern __inline int
594 fputc_unlocked (int __c, FILE *__stream) __THROW
595 {
596   return __putc (__c, __stream);
597 }
598 # endif /* Optimizing.  */
599 #endif /* Use MISC.  */
600
601 #if defined __USE_POSIX || defined __USE_MISC
602 /* These are defined in POSIX.1:1996.  */
603 extern int putc_unlocked __P ((int __c, FILE *__stream));
604 extern int putchar_unlocked __P ((int __c));
605
606 # ifdef __OPTIMIZE__
607 extern __inline int
608 putc_unlocked (int __c, FILE *__stream) __THROW
609 {
610   return __putc (__c, __stream);
611 }
612
613 extern __inline int
614 putchar_unlocked (int __c) __THROW
615 {
616   return __putc (__c, stdout);
617 }
618 # endif /* Optimizing.  */
619 #endif /* Use POSIX or MISC.  */
620
621
622 #if defined __USE_SVID || defined __USE_MISC
623 /* Get a word (int) from STREAM.  */
624 extern int getw __P ((FILE *__stream));
625
626 /* Write a word (int) to STREAM.  */
627 extern int putw __P ((int __w, FILE *__stream));
628 #endif
629
630
631 /* Get a newline-terminated string of finite length from STREAM.  */
632 extern char *fgets __P ((char *__restrict __s, int __n,
633                          FILE *__restrict __stream));
634
635 #ifdef __USE_GNU
636 /* This function does the same as `fgets' but does not lock the stream.  */
637 extern char *fgets_unlocked __P ((char *__restrict __s, int __n,
638                                   FILE *__restrict __stream));
639 #endif
640
641 /* Get a newline-terminated string from stdin, removing the newline.
642    DO NOT USE THIS FUNCTION!!  There is no limit on how much it will read.  */
643 extern char *gets __P ((char *__s));
644
645
646 #ifdef  __USE_GNU
647 #include <sys/types.h>
648
649 /* Read up to (and including) a DELIMITER from STREAM into *LINEPTR
650    (and null-terminate it). *LINEPTR is a pointer returned from malloc (or
651    NULL), pointing to *N characters of space.  It is realloc'd as
652    necessary.  Returns the number of characters read (not including the
653    null terminator), or -1 on error or EOF.  */
654 ssize_t __getdelim __P ((char **__lineptr, size_t *__n,
655                          int __delimiter, FILE *__stream));
656 ssize_t getdelim __P ((char **__lineptr, size_t *__n,
657                        int __delimiter, FILE *__stream));
658
659 /* Like `getdelim', but reads up to a newline.  */
660 ssize_t __getline __P ((char **__lineptr, size_t *__n, FILE *__stream));
661 ssize_t getline __P ((char **__lineptr, size_t *__n, FILE *__stream));
662
663 #ifdef  __OPTIMIZE__
664 extern __inline ssize_t
665 getline (char **__lineptr, size_t *__n, FILE *__stream) __THROW
666 {
667   return __getdelim (__lineptr, __n, '\n', __stream);
668 }
669 #endif /* Optimizing.  */
670 #endif
671
672
673 /* Write a string to STREAM.  */
674 extern int fputs __P ((__const char *__restrict __s,
675                        FILE *__restrict __stream));
676
677 #ifdef __USE_GNU
678 /* This function does the same as `fputs' but does not lock the stream.  */
679 extern int fputs_unlocked __P ((__const char *__restrict __s,
680                                 FILE *__restrict __stream));
681 #endif
682
683 /* Write a string, followed by a newline, to stdout.  */
684 extern int puts __P ((__const char *__s));
685
686
687 /* Push a character back onto the input buffer of STREAM.  */
688 extern int ungetc __P ((int __c, FILE *__stream));
689
690
691 /* Read chunks of generic data from STREAM.  */
692 extern size_t fread __P ((__ptr_t __restrict __ptr, size_t __size,
693                           size_t __n, FILE *__restrict __stream));
694 /* Write chunks of generic data to STREAM.  */
695 extern size_t fwrite __P ((__const __ptr_t __restrict __ptr, size_t __size,
696                            size_t __n, FILE *__restrict __s));
697
698 #ifdef __USE_MISC
699 /* Faster versions when locking is not necessary.  */
700 extern size_t fread_unlocked __P ((void *__restrict __ptr, size_t __size,
701                                    size_t __n, FILE *__restrict __stream));
702 extern size_t fwrite_unlocked __P ((__const void *__restrict __ptr,
703                                     size_t __size, size_t __n,
704                                     FILE *__restrict __stream));
705 #endif
706
707
708 /* Seek to a certain position on STREAM.  */
709 extern int fseek __P ((FILE *__stream, long int __off, int __whence));
710 /* Return the current position of STREAM.  */
711 extern long int ftell __P ((FILE *__stream));
712 /* Rewind to the beginning of STREAM.  */
713 extern void rewind __P ((FILE *__stream));
714
715 /* Get STREAM's position.  */
716 extern int fgetpos __P ((FILE *__restrict __stream, fpos_t *__restrict __pos));
717 /* Set STREAM's position.  */
718 extern int fsetpos __P ((FILE *__stream, __const fpos_t *__pos));
719
720
721 /* Clear the error and EOF indicators for STREAM.  */
722 extern void clearerr __P ((FILE *__stream));
723 /* Return the EOF indicator for STREAM.  */
724 extern int feof __P ((FILE *__stream));
725 /* Return the error indicator for STREAM.  */
726 extern int ferror __P ((FILE *__stream));
727
728 #ifdef  __OPTIMIZE__
729 #define feof(stream)    ((stream)->__eof != 0)
730 #define ferror(stream)  ((stream)->__error != 0)
731 #endif /* Optimizing.  */
732
733 #ifdef __USE_MISC
734 /* Faster versions when locking is not required.  */
735 extern void clearerr_unlocked __P ((FILE *__stream));
736 extern int feof_unlocked __P ((FILE *__stream));
737 extern int ferror_unlocked __P ((FILE *__stream));
738
739 # ifdef __OPTIMIZE__
740 #  define feof_unlocked(stream)         ((stream)->__eof != 0)
741 #  define ferror_unlocked(stream)       ((stream)->__error != 0)
742 # endif /* Optimizing.  */
743 #endif
744
745 /* Print a message describing the meaning of the value of errno.  */
746 extern void perror __P ((__const char *__s));
747
748
749 #ifdef  __USE_POSIX
750 /* Return the system file descriptor for STREAM.  */
751 extern int fileno __P ((FILE *__stream));
752 #endif /* Use POSIX.  */
753
754 #ifdef __USE_MISC
755 /* Faster version when locking is not required.  */
756 extern int fileno_unlocked __P ((FILE *__stream));
757 #endif
758
759
760 #if (defined __USE_POSIX2 || defined __USE_SVID || defined __USE_BSD || \
761      defined __USE_MISC)
762 /* Create a new stream connected to a pipe running the given command.  */
763 extern FILE *popen __P ((__const char *__command, __const char *__modes));
764
765 /* Close a stream opened by popen and return the status of its child.  */
766 extern int pclose __P ((FILE *__stream));
767 #endif
768
769
770 #ifdef  __USE_POSIX
771 /* Return the name of the controlling terminal.  */
772 extern char *ctermid __P ((char *__s));
773 #endif
774
775
776 #ifdef __USE_XOPEN
777 /* Return the name of the current user.  */
778 extern char *cuserid __P ((char *__s));
779 #endif
780
781
782 #ifdef  __USE_GNU
783 struct obstack;                 /* See <obstack.h>.  */
784
785 /* Open a stream that writes to OBSTACK.  */
786 extern FILE *open_obstack_stream __P ((struct obstack *__obstack));
787
788 /* Write formatted output to an obstack.  */
789 extern int obstack_printf __P ((struct obstack *__obstack,
790                                 __const char *__format, ...));
791 extern int obstack_vprintf __P ((struct obstack *__obstack,
792                                  __const char *__format,
793                                  __gnuc_va_list __args));
794 #endif
795
796
797 #if defined __USE_POSIX || defined __USE_MISC
798 /* These are defined in POSIX.1:1996.  */
799
800 /* Acquire ownership of STREAM.  */
801 extern void flockfile __P ((FILE *__stream));
802
803 /* Try to acquire ownership of STREAM but do not block if it is not
804    possible.  */
805 extern int ftrylockfile __P ((FILE *__stream));
806
807 /* Relinquish the ownership granted for STREAM.  */
808 extern void funlockfile __P ((FILE *__stream));
809 #endif /* POSIX || misc */
810
811 #if defined __USE_XOPEN && !defined __USE_GNU
812 /* The X/Open standard requires some functions and variables to be
813    declared here which do not belong into this header.  But we have to
814    follow.  In GNU mode we don't do this nonsense.  */
815 # define __need_getopt
816 # include <getopt.h>
817 #endif
818
819 __END_DECLS
820
821 #endif /* <stdio.h> included.  */
822
823 #endif /* stdio.h  */