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  */