stdio/internals.c

   1 /* Copyright (C) 1991, 92, 93, 94, 95, 96 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                 {
 173                   /* Seek didn't go to the right place!
 174                      This should never happen.  */
 175 #ifdef EGRATUITOUS
 176                   /* It happens in the Hurd when the io server doesn't
 177                      obey the protocol for io_seek.  */
 178                   errno = EGRATUITOUS;
 179 #else
 180                   /* I don't think this can happen in Unix.  */
 181                   errno = ESPIPE; /* ??? */
 182 #endif
 183                   fp->__error = 1;
 184                 }
 185             }
 186         }
 187     }
 188 }
 189
 190 /* Flush the buffer for FP.
 191    If C is not EOF, it is also to be written.
 192    If the stream is line buffered and C is a newline, it is written
 193    to the output, otherwise it is put in the buffer after it has been
 194    flushed to avoid a system call for a single character.
 195    This is the default `output room' function.  */
 196 static void
 197 DEFUN(flushbuf, (fp, c),
 198       register FILE *fp AND int c)
 199 {
 200   int flush_only = c == EOF;
 201   size_t buffer_written;
 202   size_t to_write;
 203
 204   /* Set if target and get_limit have already been twiddled appropriately.  */
 205   int twiddled = 0;
 206
 207   if (fp->__put_limit == fp->__buffer)
 208     {
 209       /* The stream needs to be primed for writing.  */
 210
 211       size_t buffer_offset = 0;
 212
 213       if (fp->__target == -1)
 214         /* For an unseekable object, data recently read bears no relation
 215            to data we will write later.  Discard the buffer.  */
 216         fp->__get_limit = fp->__buffer;
 217       else
 218         /* If the user has read some of the buffer, the target position
 219            is incremented for each character he has read.  */
 220         fp->__target += fp->__bufp - fp->__buffer;
 221
 222       if (fp->__mode.__read && fp->__room_funcs.__input != NULL &&
 223           !fp->__mode.__append)
 224         {
 225           int save = errno;
 226           CONST int aligned = (fp->__buffer == NULL ||
 227                                __stdio_check_offset(fp) == EOF ||
 228                                fp->__target % fp->__bufsize == 0);
 229           errno = save;
 230
 231           if (!aligned)
 232             {
 233               /* Move to a block (buffer size) boundary and read in a block.
 234                  Then the output will be written as a whole block, too.  */
 235               CONST size_t o = fp->__target % fp->__bufsize;
 236               fp->__target -= o;
 237               if ((*fp->__room_funcs.__input)(fp) == EOF && ferror(fp))
 238                 return;
 239               else
 240                 __clearerr(fp);
 241
 242               if (fp->__get_limit - fp->__buffer < o)
 243                 /* Oops.  We didn't read enough (probably because we got EOF).
 244                    Forget we even mentioned it.  */
 245                 fp->__target += o;
 246               else
 247                 /* Start bufp as far into the buffer as we were into
 248                    this block before we read it.  */
 249                 buffer_offset = o;
 250
 251               /* The target position is now set to where the beginning of the
 252                  buffer maps to; and the get_limit was set by the input-room
 253                  function.  */
 254               twiddled = 1;
 255             }
 256         }
 257
 258       if (fp->__buffer != NULL)
 259         {
 260           /* Set up to write output into the buffer.  */
 261           fp->__put_limit = fp->__buffer + fp->__bufsize;
 262           fp->__bufp = fp->__buffer + buffer_offset;
 263
 264           if (!flush_only)
 265             {
 266               /* Put C in the buffer to be written out.
 267                  We only need to actually write it out now if
 268                  it is a newline on a line-buffered stream.  */
 269               *fp->__bufp++ = (unsigned char) c;
 270               if (!fp->__linebuf || (unsigned char) c != '\n')
 271                 {
 272                   /* There is no need to flush C from the buffer right now.
 273                      Record that nothing was written from the buffer,
 274                      and go do clean-up at end.  */
 275                   buffer_written = 0;
 276                   goto end;
 277                 }
 278               else
 279                 /* We put C in the buffer, so don't write it again later.  */
 280                 flush_only = 1;
 281             }
 282         }
 283
 284       if (fp->__bufp - fp->__buffer <= buffer_offset && flush_only)
 285         {
 286           /* There is nothing new in the buffer, only data that
 287              was read back aligned from the file.  */
 288           buffer_written = 0;
 289           goto end;
 290         }
 291     }
 292
 293   /* If there is read data in the buffer past what was written,
 294      write all of that as well.  Otherwise, just write what has been
 295      written into the buffer.  */
 296   buffer_written = fp->__bufp - fp->__buffer;
 297   to_write = (buffer_written == 0 ? 0 :
 298               fp->__get_limit > fp->__bufp ?
 299               fp->__get_limit - fp->__buffer :
 300               buffer_written);
 301
 302   if (fp->__io_funcs.__write == NULL || (to_write == 0 && flush_only))
 303     {
 304       /* There is no writing function or we're coming from an fflush
 305          call with nothing in the buffer, so just say the buffer's
 306          been flushed, increment the file offset, and return.  */
 307       fp->__bufp = fp->__buffer;
 308       if (fp->__offset != -1)
 309         fp->__offset += to_write;
 310       goto end;
 311     }
 312
 313   if (to_write > 0)
 314     {
 315       int wrote;
 316
 317       /* Go to the target file position.  Don't bother if appending;
 318          the write will just ignore the file position anyway.  */
 319       if (!fp->__mode.__append)
 320         seek_to_target (fp);
 321
 322       if (!ferror(fp))
 323         {
 324           /* Write out the buffered data.  */
 325           wrote = (*fp->__io_funcs.__write)(fp->__cookie, fp->__buffer,
 326                                             to_write);
 327           if (wrote > 0)
 328             {
 329               if (fp->__mode.__append)
 330                 /* The write has written the data to the end of the file
 331                    and updated the file position to after the data.  Don't
 332                    bother to find the current position; we can get it
 333                    later if we need it.  */
 334                 fp->__offset = fp->__target = -1;
 335               else if (fp->__offset != -1)
 336                 /* Record that we've moved forward in the file.  */
 337                 fp->__offset += wrote;
 338             }
 339           if (wrote < (int) to_write)
 340             /* The writing function should always write
 341                the whole buffer unless there is an error.  */
 342             fp->__error = 1;
 343         }
 344     }
 345
 346   /* Reset the buffer pointer to the beginning of the buffer.  */
 347   fp->__bufp = fp->__buffer;
 348
 349   /* If we're not just flushing, write the last character, C.  */
 350   if (!flush_only && !ferror(fp))
 351     {
 352       if (fp->__buffer == NULL || (fp->__linebuf && (unsigned char) c == '\n'))
 353         {
 354           /* Either we're unbuffered, or we're line-buffered and
 355              C is a newline, so really write it out immediately.  */
 356           char cc = (unsigned char) c;
 357           if ((*fp->__io_funcs.__write)(fp->__cookie, &cc, 1) < 1)
 358             fp->__error = 1;
 359           else if (fp->__offset != -1)
 360             {
 361               /* Record that we've moved forward in the file.  */
 362               ++fp->__offset;
 363               ++fp->__target;
 364             }
 365         }
 366       else
 367         /* Just put C in the buffer.  */
 368         *fp->__bufp++ = (unsigned char) c;
 369     }
 370
 371  end:
 372
 373   if (!twiddled)
 374     {
 375       if (fp->__target != -1)
 376         /* The new target position moves up as
 377            much as the user wrote into the buffer.  */
 378         fp->__target += buffer_written;
 379
 380       /* Set the reading limit to the beginning of the buffer,
 381          so the next `getc' will call __fillbf.  */
 382       fp->__get_limit = fp->__buffer;
 383     }
 384
 385   if (feof(fp) || ferror(fp))
 386     fp->__bufp = fp->__put_limit;
 387 }
 388
 389
 390 /* Fill the buffer for FP and return the first character read (or EOF).
 391    This is the default `input_room' function.  */
 392 static int
 393 DEFUN(fillbuf, (fp), register FILE *fp)
 394 {
 395   /* How far into the buffer we read we want to start bufp.  */
 396   size_t buffer_offset = 0;
 397   register char *buffer;
 398   register size_t to_read, nread = 0;
 399   /* This must be unsigned to avoid sign extension in return.  */
 400   unsigned char c;
 401
 402   if (fp->__io_funcs.__read == NULL)
 403     {
 404       /* There is no read function, so always return EOF.  */
 405       fp->__eof = 1;
 406       goto end;
 407     }
 408
 409   if (fp->__buffer == NULL)
 410     {
 411       /* We're unbuffered, so we want to read only one character.  */
 412       buffer = (char *) &c;
 413       to_read = 1;
 414     }
 415   else
 416     {
 417       /* We're buffered, so try to fill the buffer.  */
 418       buffer = fp->__buffer;
 419       to_read = fp->__bufsize;
 420     }
 421
 422   /* We're reading, so we're not at the end-of-file.  */
 423   fp->__eof = 0;
 424
 425   /* Go to the target file position.  */
 426   {
 427     int save = errno;
 428     if (__stdio_check_offset (fp) == 0 && fp->__target != fp->__offset)
 429       {
 430         /* Move to a block (buffer size) boundary.  */
 431         if (fp->__bufsize != 0)
 432           {
 433             buffer_offset = fp->__target % fp->__bufsize;
 434             fp->__target -= buffer_offset;
 435           }
 436         seek_to_target (fp);
 437       }
 438     errno = save;
 439   }
 440
 441   while (!ferror(fp) && !feof(fp) && nread <= buffer_offset)
 442     {
 443       /* Try to fill the buffer.  */
 444       int count = (*fp->__io_funcs.__read)(fp->__cookie, buffer, to_read);
 445       if (count == 0)
 446         fp->__eof = 1;
 447       else if (count < 0)
 448         fp->__error = 1;
 449       else
 450         {
 451           buffer += count;
 452           nread += count;
 453           to_read -= count;
 454           if (fp->__offset != -1)
 455             /* Record that we've moved forward in the file.  */
 456             fp->__offset += count;
 457         }
 458     }
 459
 460   if (fp->__buffer == NULL)
 461     /* There is no buffer, so return the character we read
 462        without all the buffer pointer diddling.  */
 463     return (feof(fp) || ferror(fp)) ? EOF : c;
 464
 465   /* Reset the buffer pointer to the beginning of the buffer
 466      (plus whatever offset we may have set above).  */
 467   fp->__bufp = fp->__buffer + buffer_offset;
 468
 469  end:;
 470
 471   if (feof(fp) || ferror(fp))
 472     {
 473       /* Set both end pointers to the beginning of the buffer so
 474          the next i/o call will force a call to __fillbf/__flshfp.  */
 475       fp->__put_limit = fp->__get_limit = fp->__buffer;
 476       return EOF;
 477     }
 478
 479   /* Set the end pointer to one past the last character we read.  */
 480   fp->__get_limit = fp->__buffer + nread;
 481
 482   /* Make it so the next `putc' will call __flshfp.  */
 483   fp->__put_limit = fp->__buffer;
 484
 485   /* Return the first character in the buffer.  */
 486   return *((unsigned char *) (fp->__bufp++));
 487 }
 488
 489
 490 /* Default I/O and room functions.  */
 491
 492 extern __io_read_fn __stdio_read;
 493 extern __io_write_fn __stdio_write;
 494 extern __io_seek_fn __stdio_seek;
 495 extern __io_close_fn __stdio_close;
 496 extern __io_fileno_fn __stdio_fileno;
 497 CONST __io_functions __default_io_functions =
 498   {
 499     __stdio_read, __stdio_write, __stdio_seek, __stdio_close, __stdio_fileno
 500   };
 501
 502 CONST __room_functions __default_room_functions =
 503   {
 504     fillbuf, flushbuf
 505   };
 506
 507
 508 /* Flush the buffer for FP and also write C if FLUSH_ONLY is nonzero.
 509    This is the function used by putc and fflush.  */
 510 int
 511 DEFUN(__flshfp, (fp, c),
 512       register FILE *fp AND int c)
 513 {
 514   int flush_only = c == EOF;
 515
 516   if (!__validfp(fp) || !fp->__mode.__write)
 517     {
 518       errno = EINVAL;
 519       return EOF;
 520     }
 521
 522   if (ferror(fp))
 523     return EOF;
 524
 525   if (fp->__pushed_back)
 526     {
 527       /* Discard the char pushed back by ungetc.  */
 528       fp->__bufp = fp->__pushback_bufp;
 529       fp->__pushed_back = 0;
 530     }
 531
 532   /* Make sure the stream is initialized (has functions and buffering).  */
 533   init_stream(fp);
 534
 535   /* Do this early, so a `putc' on such a stream will never return success.  */
 536   if (fp->__room_funcs.__output == NULL)
 537     {
 538       /* A NULL `output room' function means
 539          to always return an output error.  */
 540       fp->__error = 1;
 541       return EOF;
 542     }
 543
 544   if (!flush_only &&
 545       /* Will C fit into the buffer?
 546          See below about linebuf_active.  */
 547       fp->__bufp < (fp->__linebuf_active ? fp->__buffer + fp->__bufsize :
 548                     fp->__put_limit))
 549     {
 550       /* The character will fit in the buffer, so put it there.  */
 551       *fp->__bufp++ = (unsigned char) c;
 552       if (fp->__linebuf && (unsigned char) c == '\n')
 553         flush_only = 1;
 554       else
 555         return (unsigned char) c;
 556     }
 557
 558   if (fp->__linebuf_active)
 559     /* This is an active line-buffered stream, so its put-limit is set
 560        to the beginning of the buffer in order to force a __flshfp call
 561        on each putc (see below).  We undo this hack here (by setting
 562        the limit to the end of the buffer) to simplify the interface
 563        with the output-room function.  */
 564     fp->__put_limit = fp->__buffer + fp->__bufsize;
 565
 566   /* Make room in the buffer.  */
 567   (*fp->__room_funcs.__output) (fp, flush_only ? EOF : (unsigned char) c);
 568
 569   if (fp->__linebuf)
 570     {
 571       /* This is a line-buffered stream, and it is now ready to do
 572          some output.  We call this an "active line-buffered stream".
 573          We set the put_limit to the beginning of the buffer,
 574          so the next `putc' call will force a call to this function.
 575          Setting the linebuf_active flag tells the code above
 576          (on the next call) to undo this hackery.  */
 577       fp->__put_limit = fp->__buffer;
 578       fp->__linebuf_active = 1;
 579     }
 580
 581   if (ferror (fp))
 582     return EOF;
 583   if (flush_only)
 584     return 0;
 585   return (unsigned char) c;
 586 }
 587
 588
 589 /* Fill the buffer for FP and return the first character read.
 590    This is the function used by getc.  */
 591 int
 592 DEFUN(__fillbf, (fp), register FILE *fp)
 593 {
 594   register int c;
 595   fpos_t new_target;
 596
 597   if (!__validfp(fp) || !fp->__mode.__read)
 598     {
 599       errno = EINVAL;
 600       return EOF;
 601     }
 602
 603   if (fp->__pushed_back)
 604     {
 605       /* Return the char pushed back by ungetc.  */
 606       fp->__bufp = fp->__pushback_bufp;
 607       fp->__pushed_back = 0;
 608       return fp->__pushback;
 609     }
 610
 611   /* Make sure the stream is initialized (has functions and buffering). */
 612   init_stream(fp);
 613
 614   /* If we're trying to read the first character of a new
 615      line of input from an unbuffered or line buffered stream,
 616      we must flush all line-buffered output streams. */
 617   if (fp->__buffer == NULL || fp->__linebuf)
 618     {
 619       register FILE *f;
 620       for (f = __stdio_head; f != NULL; f = f->__next)
 621         if (__validfp (f) && f->__linebuf && f->__mode.__write)
 622           (void) __flshfp (f, EOF);
 623     }
 624
 625   /* Note we must do this after flushing all line-buffered
 626      streams, or else __flshfp would undo it!  */
 627   if (fp->__linebuf_active)
 628     {
 629       /* This is an active line-buffered stream, meaning it is in the midst
 630          of writing, but has a bogus put_limit.  Restore it to normality.  */
 631       fp->__put_limit = fp->__buffer + fp->__bufsize;
 632       fp->__linebuf_active = 0;
 633     }
 634
 635   /* We want the beginning of the buffer to now
 636      map to just past the last data we read.  */
 637   new_target = fp->__target + (fp->__get_limit - fp->__buffer);
 638
 639   if (fp->__put_limit > fp->__buffer)
 640     {
 641       /* There is written data in the buffer.
 642          Flush it out.  */
 643       if (fp->__room_funcs.__output == NULL)
 644         fp->__error = 1;
 645       else
 646         (*fp->__room_funcs.__output) (fp, EOF);
 647     }
 648
 649   fp->__target = new_target;
 650
 651   if (ferror(fp))
 652     c = EOF;
 653   else if (fp->__room_funcs.__input != NULL)
 654     {
 655       c = (*fp->__room_funcs.__input)(fp);
 656       if (fp->__buffer == NULL)
 657         /* This is an unbuffered stream, so the target sync above
 658            won't do anything the next time around.  Instead, note that
 659            we have read one character.  The (nonexistent) buffer now
 660            maps to the position just past that character.  */
 661         ++fp->__target;
 662     }
 663   else
 664     {
 665       /* A NULL `input_room' function means always return EOF.  */
 666       fp->__eof = 1;
 667       c = EOF;
 668     }
 669
 670   return c;
 671 }
 672
 673
 674 /* Nuke a stream, but don't kill its link in the chain.  */
 675 void
 676 DEFUN(__invalidate, (stream), register FILE *stream)
 677 {
 678   /* Save its link.  */
 679   register FILE *next = stream->__next;
 680
 681   /* Pulverize the fucker.  */
 682   memset((PTR) stream, 0, sizeof(FILE));
 683
 684   /* Restore the deceased's link.  */
 685   stream->__next = next;
 686 }