stdio/internals.c

   1 /* Copyright (C) 1991, 1992, 1993 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
  16 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  17 Cambridge, MA 02139, USA.  */
  18
  19 #include <ansidecl.h>
  20 #include <errno.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25
  26 /* Make sure that FP has its functions set.  */
  27 void
  28 DEFUN(__stdio_check_funcs, (fp), register FILE *fp)
  29 {
  30   if (!fp->__seen)
  31     {
  32       /* Initialize the stream's info, including buffering info.
  33          This may give a buffer, change I/O functions, etc.
  34          If no buffer is set (and the stream is not made explicitly
  35          unbuffered), we allocate a buffer below, using the bufsize
  36          set by this function.  */
  37       extern void EXFUN(__stdio_init_stream, (FILE *));
  38       fp->__room_funcs = __default_room_functions;
  39       fp->__io_funcs = __default_io_functions;
  40       __stdio_init_stream (fp);
  41       fp->__seen = 1;
  42     }
  43 }
  44
  45
  46 /* Minimum size of a buffer we will allocate by default.
  47    If this much memory is not available,
  48    the stream in question will be made unbuffered instead.  */
  49 #define MIN_BUFSIZE     128
  50
  51 /* Figure out what kind of buffering (none, line, or full)
  52    and what buffer size to give FP.  */
  53 static void
  54 DEFUN(init_stream, (fp), register FILE *fp)
  55 {
  56   __stdio_check_funcs (fp);
  57
  58   if (fp->__buffer == NULL && !fp->__userbuf)
  59     {
  60       int save;
  61
  62       if (fp->__bufsize == 0)
  63         fp->__bufsize = BUFSIZ;
  64
  65       /* Try to get however many bytes of buffering __stdio_pickbuf
  66          specified, but if that much memory isn't available,
  67          try half as much each time until it succeeds or the buffer
  68          size becomes too small to be useful.  */
  69       save = errno;
  70       while (fp->__bufsize >= MIN_BUFSIZE)
  71         {
  72           fp->__buffer = (char *) malloc(fp->__bufsize);
  73           if (fp->__buffer == NULL)
  74             fp->__bufsize /= 2;
  75           else
  76             break;
  77         }
  78       errno = save;
  79
  80       if (fp->__buffer == NULL)
  81         {
  82           /* We can't get space for the buffer, so make it unbuffered.  */
  83           fp->__userbuf = 1;
  84           fp->__bufsize = 0;
  85         }
  86     }
  87
  88   if (fp->__bufp == NULL)
  89     {
  90       /* Set the buffer pointer to the beginning of the buffer.  */
  91       fp->__bufp = fp->__buffer;
  92       fp->__put_limit = fp->__get_limit = fp->__buffer;
  93     }
  94 }
  95
  96
  97 /* Determine the current file position of STREAM if it is unknown.  */
  98 int
  99 DEFUN(__stdio_check_offset, (stream), FILE *stream)
 100 {
 101   init_stream (stream);
 102
 103   if (stream->__offset == (fpos_t) -1)
 104     {
 105       /* This stream's offset is unknown or unknowable.  */
 106       if (stream->__io_funcs.__seek == NULL)
 107         {
 108           /* Unknowable.  */
 109           errno = ESPIPE;
 110           return EOF;
 111         }
 112       else
 113         {
 114           /* Unknown.  Find it out.  */
 115           fpos_t pos = (fpos_t) 0;
 116           if ((*stream->__io_funcs.__seek)(stream->__cookie,
 117                                            &pos, SEEK_CUR) < 0)
 118             {
 119               if (errno == ESPIPE)
 120                 /* Object is incapable of seeking.  */
 121                 stream->__io_funcs.__seek = NULL;
 122               return EOF;
 123             }
 124           stream->__offset = pos;
 125         }
 126     }
 127
 128   if (stream->__target == (fpos_t) -1)
 129     /* This stream was opened on an existing object with
 130        an unknown file position.  The position is now known.
 131        Make this the target position.  */
 132     stream->__target = stream->__offset;
 133
 134   return 0;
 135 }
 136
 137
 138 /* Move FP's file position to its target file position,
 139    seeking as necessary and updating its `offset' field.
 140    Sets ferror(FP) (and possibly errno) for errors.  */
 141 static void
 142 DEFUN(seek_to_target, (fp), FILE *fp)
 143 {
 144   int save = errno;
 145   if (__stdio_check_offset (fp) == EOF)
 146     {
 147       if (errno == ESPIPE)
 148         errno = save;
 149       else
 150         fp->__error = 1;
 151     }
 152   else if (fp->__target != fp->__offset)
 153     {
 154       /* We are not at the target file position.
 155          Seek to that position.  */
 156       if (fp->__io_funcs.__seek == NULL)
 157         {
 158           /* We can't seek!  */
 159           errno = ESPIPE;
 160           fp->__error = 1;
 161         }
 162       else
 163         {
 164           fpos_t pos = fp->__target;
 165           if ((*fp->__io_funcs.__seek)(fp->__cookie, &pos, SEEK_SET) < 0)
 166             /* Seek failed!  */
 167             fp->__error = 1;
 168           else
 169             {
 170               fp->__offset = pos;
 171               if (pos != fp->__target)
 172                 /* Seek didn't go to the right place!  */
 173                 fp->__error = 1;
 174             }
 175         }
 176     }
 177 }
 178
 179 /* Flush the buffer for FP.
 180    If C is not EOF, it is also to be written.
 181    If the stream is line buffered and C is a newline, it is written
 182    to the output, otherwise it is put in the buffer after it has been
 183    flushed to avoid a system call for a single character.
 184    This is the default `output room' function.  */
 185 static void
 186 DEFUN(flushbuf, (fp, c),
 187       register FILE *fp AND int c)
 188 {
 189   int flush_only = c == EOF;
 190   size_t buffer_written;
 191   size_t to_write;
 192
 193   /* Set if target and get_limit have already been twiddled appropriately.  */
 194   int twiddled = 0;
 195
 196   if (fp->__put_limit == fp->__buffer)
 197     {
 198       /* The stream needs to be primed for writing.  */
 199
 200       size_t buffer_offset = 0;
 201
 202       /* If the user has read some of the buffer, the target position
 203          is incremented for each character he has read.  */
 204       fp->__target += fp->__bufp - fp->__buffer;
 205
 206       if (fp->__mode.__read && fp->__room_funcs.__input != NULL &&
 207           !fp->__mode.__append)
 208         {
 209           int save = errno;
 210           CONST int aligned = (__stdio_check_offset(fp) == EOF ||
 211                                fp->__target % fp->__bufsize == 0);
 212           errno = save;
 213
 214           if (!aligned)
 215             {
 216               /* Move to a block (buffer size) boundary and read in a block.
 217                  Then the output will be written as a whole block, too.  */
 218               CONST size_t o = fp->__target % fp->__bufsize;
 219               fp->__target -= o;
 220               if ((*fp->__room_funcs.__input)(fp) == EOF && ferror(fp))
 221                 return;
 222               else
 223                 __clearerr(fp);
 224
 225               if (fp->__get_limit - fp->__buffer < o)
 226                 /* Oops.  We didn't read enough (probably because we got EOF).
 227                    Forget we even mentioned it.  */
 228                 fp->__target += o;
 229               else
 230                 /* Start bufp as far into the buffer as we were into
 231                    this block before we read it.  */
 232                 buffer_offset = o;
 233             }
 234
 235           /* The target position is now set to where the beginning of the
 236              buffer maps to; and the get_limit was set by the input-room
 237              function.  */
 238           twiddled = 1;
 239         }
 240
 241       if (fp->__buffer != NULL)
 242         {
 243           /* Set up to write output into the buffer.  */
 244           fp->__put_limit = fp->__buffer + fp->__bufsize;
 245           fp->__bufp = fp->__buffer + buffer_offset;
 246
 247           if (!flush_only)
 248             {
 249               /* Put C in the buffer to be written out.
 250                  We only need to actually write it out now if
 251                  it is a newline on a line-buffered stream.  */
 252               *fp->__bufp++ = (unsigned char) c;
 253               if (!fp->__linebuf || (unsigned char) c != '\n')
 254                 {
 255                   /* There is no need to flush C from the buffer right now.
 256                      Record that nothing was written from the buffer,
 257                      and go do clean-up at end.  */
 258                   buffer_written = 0;
 259                   goto end;
 260                 }
 261               else
 262                 /* We put C in the buffer, so don't write it again later.  */
 263                 flush_only = 1;
 264             }
 265         }
 266     }
 267
 268   /* If there is read data in the buffer past what was written,
 269      write all of that as well.  Otherwise, just write what has been
 270      written into the buffer.  */
 271   buffer_written = fp->__bufp - fp->__buffer;
 272   to_write = (buffer_written == 0 ? 0 :
 273               fp->__get_limit > fp->__bufp ?
 274               fp->__get_limit - fp->__buffer :
 275               buffer_written);
 276
 277   if (fp->__io_funcs.__write == NULL || (to_write == 0 && flush_only))
 278     {
 279       /* There is no writing function or we're coming from an fflush
 280          call with nothing in the buffer, so just say the buffer's
 281          been flushed, increment the file offset, and return.  */
 282       fp->__bufp = fp->__buffer;
 283       fp->__offset += to_write;
 284       goto end;
 285     }
 286
 287   if (to_write > 0)
 288     {
 289       int wrote;
 290
 291       /* Go to the target file position.  Don't bother if appending;
 292          the write will just ignore the file position anyway.  */
 293       if (!fp->__mode.__append)
 294         seek_to_target (fp);
 295
 296       if (!ferror(fp))
 297         {
 298           /* Write out the buffered data.  */
 299           wrote = (*fp->__io_funcs.__write)(fp->__cookie, fp->__buffer,
 300                                             to_write);
 301           if (wrote > 0)
 302             {
 303               if (fp->__mode.__append)
 304                 /* The write has written the data to the end of the file
 305                    and updated the file position to after the data.  Don't
 306                    bother to find the current position; we can get it
 307                    later if we need it.  */
 308                 fp->__offset = fp->__target = -1;
 309               else
 310                 /* Record that we've moved forward in the file.  */
 311                 fp->__offset += wrote;
 312             }
 313           if (wrote < (int) to_write)
 314             /* The writing function should always write
 315                the whole buffer unless there is an error.  */
 316             fp->__error = 1;
 317         }
 318     }
 319
 320   /* Reset the buffer pointer to the beginning of the buffer.  */
 321   fp->__bufp = fp->__buffer;
 322
 323   /* If we're not just flushing, write the last character, C.  */
 324   if (!flush_only && !ferror(fp))
 325     {
 326       if (fp->__buffer == NULL || (fp->__linebuf && (unsigned char) c == '\n'))
 327         {
 328           /* Either we're unbuffered, or we're line-buffered and
 329              C is a newline, so really write it out immediately.  */
 330           char cc = (unsigned char) c;
 331           if ((*fp->__io_funcs.__write)(fp->__cookie, &cc, 1) < 1)
 332             fp->__error = 1;
 333           else
 334             {
 335               /* Record that we've moved forward in the file.  */
 336               ++fp->__offset;
 337               ++fp->__target;
 338             }
 339         }
 340       else
 341         /* Just put C in the buffer.  */
 342         *fp->__bufp++ = (unsigned char) c;
 343     }
 344
 345  end:
 346
 347   if (!twiddled)
 348     {
 349       /* The new target position moves up as
 350          much as the user wrote into the buffer.  */
 351       fp->__target += buffer_written;
 352
 353       /* Set the reading limit to the beginning of the buffer,
 354          so the next `getc' will call __fillbf.  */
 355       fp->__get_limit = fp->__buffer;
 356     }
 357
 358   if (feof(fp) || ferror(fp))
 359     fp->__bufp = fp->__put_limit;
 360 }
 361
 362
 363 /* Fill the buffer for FP and return the first character read (or EOF).
 364    This is the default `input_room' function.  */
 365 static int
 366 DEFUN(fillbuf, (fp), register FILE *fp)
 367 {
 368   /* How far into the buffer we read we want to start bufp.  */
 369   size_t buffer_offset = 0;
 370   register char *buffer;
 371   register size_t to_read, nread = 0;
 372   char c;
 373
 374   if (fp->__io_funcs.__read == NULL)
 375     {
 376       /* There is no read function, so always return EOF.  */
 377       fp->__eof = 1;
 378       goto end;
 379     }
 380
 381   if (fp->__buffer == NULL)
 382     {
 383       /* We're unbuffered, so we want to read only one character.  */
 384       buffer = &c;
 385       to_read = 1;
 386     }
 387   else
 388     {
 389       /* We're buffered, so try to fill the buffer.  */
 390       buffer = fp->__buffer;
 391       to_read = fp->__bufsize;
 392     }
 393
 394   /* We're reading, so we're not at the end-of-file.  */
 395   fp->__eof = 0;
 396
 397   /* Go to the target file position.  */
 398   {
 399     int save = errno;
 400     if (__stdio_check_offset (fp) == 0 && fp->__target != fp->__offset)
 401       {
 402         /* Move to a block (buffer size) boundary.  */
 403         if (fp->__bufsize != 0)
 404           {
 405             buffer_offset = fp->__target % fp->__bufsize;
 406             fp->__target -= buffer_offset;
 407           }
 408         seek_to_target (fp);
 409       }
 410     errno = save;
 411   }
 412
 413   while (!ferror(fp) && !feof(fp) && nread <= buffer_offset)
 414     {
 415       /* Try to fill the buffer.  */
 416       int count = (*fp->__io_funcs.__read)(fp->__cookie, buffer, to_read);
 417       if (count == 0)
 418         fp->__eof = 1;
 419       else if (count < 0)
 420         fp->__error = 1;
 421       else
 422         {
 423           buffer += count;
 424           nread += count;
 425           to_read -= count;
 426           /* Record that we've moved forward in the file.  */
 427           fp->__offset += count;
 428         }
 429     }
 430
 431   if (fp->__buffer == NULL)
 432     /* There is no buffer, so return the character we read
 433        without all the buffer pointer diddling.  */
 434     return (feof(fp) || ferror(fp)) ? EOF : c;
 435
 436   /* Reset the buffer pointer to the beginning of the buffer
 437      (plus whatever offset we may have set above).  */
 438   fp->__bufp = fp->__buffer + buffer_offset;
 439
 440  end:;
 441
 442   if (feof(fp) || ferror(fp))
 443     {
 444       /* Set both end pointers to the beginning of the buffer so
 445          the next i/o call will force a call to __fillbf/__flshfp.  */
 446       fp->__put_limit = fp->__get_limit = fp->__buffer;
 447       return EOF;
 448     }
 449
 450   /* Set the end pointer to one past the last character we read.  */
 451   fp->__get_limit = fp->__buffer + nread;
 452
 453   /* Make it so the next `putc' will call __flshfp.  */
 454   fp->__put_limit = fp->__buffer;
 455
 456   /* Return the first character in the buffer.  */
 457   return (unsigned char) *fp->__bufp++;
 458 }
 459
 460
 461 /* Default I/O and room functions.  */
 462
 463 extern __io_read_fn __stdio_read;
 464 extern __io_write_fn __stdio_write;
 465 extern __io_seek_fn __stdio_seek;
 466 extern __io_close_fn __stdio_close;
 467 extern __io_fileno_fn __stdio_fileno;
 468 CONST __io_functions __default_io_functions =
 469   {
 470     __stdio_read, __stdio_write, __stdio_seek, __stdio_close, __stdio_fileno
 471   };
 472
 473 CONST __room_functions __default_room_functions =
 474   {
 475     fillbuf, flushbuf
 476   };
 477
 478
 479 /* Flush the buffer for FP and also write C if FLUSH_ONLY is nonzero.
 480    This is the function used by putc and fflush.  */
 481 int
 482 DEFUN(__flshfp, (fp, c),
 483       register FILE *fp AND int c)
 484 {
 485   int flush_only = c == EOF;
 486
 487   if (!__validfp(fp) || !fp->__mode.__write)
 488     {
 489       errno = EINVAL;
 490       return EOF;
 491     }
 492
 493   if (ferror(fp))
 494     return EOF;
 495
 496   if (fp->__pushed_back)
 497     {
 498       /* Discard the char pushed back by ungetc.  */
 499       fp->__bufp = fp->__pushback_bufp;
 500       fp->__pushed_back = 0;
 501     }
 502
 503   /* Make sure the stream is initialized (has functions and buffering).  */
 504   init_stream(fp);
 505
 506   /* Do this early, so a `putc' on such a stream will never return success.  */
 507   if (fp->__room_funcs.__output == NULL)
 508     {
 509       /* A NULL `output room' function means
 510          to always return an output error.  */
 511       fp->__error = 1;
 512       return EOF;
 513     }
 514
 515   if (!flush_only &&
 516       /* Will C fit into the buffer?
 517          See below about linebuf_active.  */
 518       fp->__bufp < (fp->__linebuf_active ? fp->__buffer + fp->__bufsize :
 519                     fp->__put_limit))
 520     {
 521       /* The character will fit in the buffer, so put it there.  */
 522       *fp->__bufp++ = (unsigned char) c;
 523       if (fp->__linebuf && (unsigned char) c == '\n')
 524         flush_only = 1;
 525       else
 526         return (unsigned char) c;
 527     }
 528
 529   if (fp->__linebuf_active)
 530     /* This is an active line-buffered stream, so its put-limit is set
 531        to the beginning of the buffer in order to force a __flshfp call
 532        on each putc (see below).  We undo this hack here (by setting
 533        the limit to the end of the buffer) to simplify the interface
 534        with the output-room function.  */
 535     fp->__put_limit = fp->__buffer + fp->__bufsize;
 536
 537   /* Make room in the buffer.  */
 538   (*fp->__room_funcs.__output) (fp, flush_only ? EOF : (unsigned char) c);
 539
 540   if (fp->__linebuf)
 541     {
 542       /* This is a line-buffered stream, and it is now ready to do
 543          some output.  We call this an "active line-buffered stream".
 544          We set the put_limit to the beginning of the buffer,
 545          so the next `putc' call will force a call to this function.
 546          Setting the linebuf_active flag tells the code above
 547          (on the next call) to undo this hackery.  */
 548       fp->__put_limit = fp->__buffer;
 549       fp->__linebuf_active = 1;
 550     }
 551
 552   if (ferror (fp))
 553     return EOF;
 554   if (flush_only)
 555     return 0;
 556   return (unsigned char) c;
 557 }
 558
 559
 560 /* Fill the buffer for FP and return the first character read.
 561    This is the function used by getc.  */
 562 int
 563 DEFUN(__fillbf, (fp), register FILE *fp)
 564 {
 565   register int c;
 566   fpos_t new_target;
 567
 568   if (!__validfp(fp) || !fp->__mode.__read)
 569     {
 570       errno = EINVAL;
 571       return EOF;
 572     }
 573
 574   if (fp->__pushed_back)
 575     {
 576       /* Return the char pushed back by ungetc.  */
 577       fp->__bufp = fp->__pushback_bufp;
 578       fp->__pushed_back = 0;
 579       return fp->__pushback;
 580     }
 581
 582   /* Make sure the stream is initialized (has functions and buffering). */
 583   init_stream(fp);
 584
 585   /* If we're trying to read the first character of a new
 586      line of input from an unbuffered or line buffered stream,
 587      we must flush all line-buffered output streams. */
 588   if (fp->__buffer == NULL || fp->__linebuf)
 589     {
 590       register FILE *f;
 591       for (f = __stdio_head; f != NULL; f = f->__next)
 592         if (__validfp (f) && f->__linebuf && f->__mode.__write)
 593           (void) __flshfp (f, EOF);
 594     }
 595
 596   /* Note we must do this after flushing all line-buffered
 597      streams, or else __flshfp would undo it!  */
 598   if (fp->__linebuf_active)
 599     {
 600       /* This is an active line-buffered stream, meaning it is in the midst
 601          of writing, but has a bogus put_limit.  Restore it to normality.  */
 602       fp->__put_limit = fp->__buffer + fp->__bufsize;
 603       fp->__linebuf_active = 0;
 604     }
 605
 606   /* We want the beginning of the buffer to now
 607      map to just past the last data we read.  */
 608   new_target = fp->__target + (fp->__get_limit - fp->__buffer);
 609
 610   if (fp->__put_limit > fp->__buffer)
 611     {
 612       /* There is written data in the buffer.
 613          Flush it out.  */
 614       if (fp->__room_funcs.__output == NULL)
 615         fp->__error = 1;
 616       else
 617         (*fp->__room_funcs.__output) (fp, EOF);
 618     }
 619
 620   fp->__target = new_target;
 621
 622   if (ferror(fp))
 623     c = EOF;
 624   else if (fp->__room_funcs.__input != NULL)
 625     {
 626       c = (*fp->__room_funcs.__input)(fp);
 627       if (fp->__buffer == NULL)
 628         /* This is an unbuffered stream, so the target sync above
 629            won't do anything the next time around.  Instead, note that
 630            we have read one character.  The (nonexistent) buffer now
 631            maps to the position just past that character.  */
 632         ++fp->__target;
 633     }
 634   else
 635     {
 636       /* A NULL `input_room' function means always return EOF.  */
 637       fp->__eof = 1;
 638       c = EOF;
 639     }
 640
 641   return c;
 642 }
 643
 644
 645 /* Nuke a stream, but don't kill its link in the chain.  */
 646 void
 647 DEFUN(__invalidate, (stream), register FILE *stream)
 648 {
 649   /* Save its link.  */
 650   register FILE *next = stream->__next;
 651
 652   /* Pulverize the fucker.  */
 653   memset((PTR) stream, 0, sizeof(FILE));
 654
 655   /* Restore the deceased's link.  */
 656   stream->__next = next;
 657 }