stdio/internals.c

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