stdio/internals.c

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