diff options
Diffstat (limited to 'stdio/internals.c')
| -rw-r--r-- | stdio/internals.c | 667 |
1 files changed, 667 insertions, 0 deletions
diff --git a/stdio/internals.c b/stdio/internals.c new file mode 100644 index 0000000000..b01c5bd531 --- /dev/null +++ b/stdio/internals.c @@ -0,0 +1,667 @@ +/* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc. +This file is part of the GNU C Library. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 of the +License, or (at your option) any later version. + +The GNU C Library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#include <ansidecl.h> +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + + +/* Make sure that FP has its functions set. */ +void +DEFUN(__stdio_check_funcs, (fp), register FILE *fp) +{ + if (!fp->__seen) + { + /* Initialize the stream's info, including buffering info. + This may give a buffer, change I/O functions, etc. + If no buffer is set (and the stream is not made explicitly + unbuffered), we allocate a buffer below, using the bufsize + set by this function. */ + extern void EXFUN(__stdio_init_stream, (FILE *)); + fp->__room_funcs = __default_room_functions; + fp->__io_funcs = __default_io_functions; + __stdio_init_stream (fp); + fp->__seen = 1; + } +} + + +/* Minimum size of a buffer we will allocate by default. + If this much memory is not available, + the stream in question will be made unbuffered instead. */ +#define MIN_BUFSIZE 128 + +/* Figure out what kind of buffering (none, line, or full) + and what buffer size to give FP. */ +static void +DEFUN(init_stream, (fp), register FILE *fp) +{ + __stdio_check_funcs (fp); + + if (fp->__buffer == NULL && !fp->__userbuf) + { + int save; + + if (fp->__bufsize == 0) + fp->__bufsize = BUFSIZ; + + /* Try to get however many bytes of buffering __stdio_pickbuf + specified, but if that much memory isn't available, + try half as much each time until it succeeds or the buffer + size becomes too small to be useful. */ + save = errno; + while (fp->__bufsize >= MIN_BUFSIZE) + { + fp->__buffer = (char *) malloc(fp->__bufsize); + if (fp->__buffer == NULL) + fp->__bufsize /= 2; + else + break; + } + errno = save; + + if (fp->__buffer == NULL) + { + /* We can't get space for the buffer, so make it unbuffered. */ + fp->__userbuf = 1; + fp->__bufsize = 0; + } + } + + if (fp->__bufp == NULL) + { + /* Set the buffer pointer to the beginning of the buffer. */ + fp->__bufp = fp->__buffer; + fp->__put_limit = fp->__get_limit = fp->__buffer; + } +} + + +/* Determine the current file position of STREAM if it is unknown. */ +int +DEFUN(__stdio_check_offset, (stream), FILE *stream) +{ + init_stream (stream); + + if (stream->__offset == (fpos_t) -1) + { + /* This stream's offset is unknown or unknowable. */ + if (stream->__io_funcs.__seek == NULL) + { + /* Unknowable. */ + errno = ESPIPE; + return EOF; + } + else + { + /* Unknown. Find it out. */ + fpos_t pos = (fpos_t) 0; + if ((*stream->__io_funcs.__seek)(stream->__cookie, + &pos, SEEK_CUR) < 0) + { + if (errno == ESPIPE) + /* Object is incapable of seeking. */ + stream->__io_funcs.__seek = NULL; + return EOF; + } + stream->__offset = pos; + } + } + + if (stream->__target == (fpos_t) -1) + /* This stream was opened on an existing object with + an unknown file position. The position is now known. + Make this the target position. */ + stream->__target = stream->__offset; + + return 0; +} + + +/* Move FP's file position to its target file position, + seeking as necessary and updating its `offset' field. + Sets ferror(FP) (and possibly errno) for errors. */ +static void +DEFUN(seek_to_target, (fp), FILE *fp) +{ + int save = errno; + if (__stdio_check_offset (fp) == EOF) + { + if (errno == ESPIPE) + errno = save; + else + fp->__error = 1; + } + else if (fp->__target != fp->__offset) + { + /* We are not at the target file position. + Seek to that position. */ + if (fp->__io_funcs.__seek == NULL) + { + /* We can't seek! */ + errno = ESPIPE; + fp->__error = 1; + } + else + { + fpos_t pos = fp->__target; + if ((*fp->__io_funcs.__seek)(fp->__cookie, &pos, SEEK_SET) < 0) + /* Seek failed! */ + fp->__error = 1; + else + { + fp->__offset = pos; + if (pos != fp->__target) + /* Seek didn't go to the right place! */ + fp->__error = 1; + } + } + } +} + +/* Flush the buffer for FP. + If C is not EOF, it is also to be written. + If the stream is line buffered and C is a newline, it is written + to the output, otherwise it is put in the buffer after it has been + flushed to avoid a system call for a single character. + This is the default `output room' function. */ +static void +DEFUN(flushbuf, (fp, c), + register FILE *fp AND int c) +{ + int flush_only = c == EOF; + size_t buffer_written; + size_t to_write; + + /* Set if target and get_limit have already been twiddled appropriately. */ + int twiddled = 0; + + if (fp->__put_limit == fp->__buffer) + { + /* The stream needs to be primed for writing. */ + + size_t buffer_offset = 0; + + /* If the user has read some of the buffer, the target position + is incremented for each character he has read. */ + fp->__target += fp->__bufp - fp->__buffer; + + if (fp->__mode.__read && fp->__room_funcs.__input != NULL && + !fp->__mode.__append) + { + int save = errno; + CONST int aligned = (fp->__buffer == NULL || + __stdio_check_offset(fp) == EOF || + fp->__target % fp->__bufsize == 0); + errno = save; + + if (!aligned) + { + /* Move to a block (buffer size) boundary and read in a block. + Then the output will be written as a whole block, too. */ + CONST size_t o = fp->__target % fp->__bufsize; + fp->__target -= o; + if ((*fp->__room_funcs.__input)(fp) == EOF && ferror(fp)) + return; + else + __clearerr(fp); + + if (fp->__get_limit - fp->__buffer < o) + /* Oops. We didn't read enough (probably because we got EOF). + Forget we even mentioned it. */ + fp->__target += o; + else + /* Start bufp as far into the buffer as we were into + this block before we read it. */ + buffer_offset = o; + } + + /* The target position is now set to where the beginning of the + buffer maps to; and the get_limit was set by the input-room + function. */ + twiddled = 1; + } + + if (fp->__buffer != NULL) + { + /* Set up to write output into the buffer. */ + fp->__put_limit = fp->__buffer + fp->__bufsize; + fp->__bufp = fp->__buffer + buffer_offset; + + if (!flush_only) + { + /* Put C in the buffer to be written out. + We only need to actually write it out now if + it is a newline on a line-buffered stream. */ + *fp->__bufp++ = (unsigned char) c; + if (!fp->__linebuf || (unsigned char) c != '\n') + { + /* There is no need to flush C from the buffer right now. + Record that nothing was written from the buffer, + and go do clean-up at end. */ + buffer_written = 0; + goto end; + } + else + /* We put C in the buffer, so don't write it again later. */ + flush_only = 1; + } + } + + if (fp->__bufp - fp->__buffer <= buffer_offset) + { + /* There is nothing new in the buffer, only data that + was read back aligned from the file. */ + buffer_written = 0; + goto end; + } + } + + /* If there is read data in the buffer past what was written, + write all of that as well. Otherwise, just write what has been + written into the buffer. */ + buffer_written = fp->__bufp - fp->__buffer; + to_write = (buffer_written == 0 ? 0 : + fp->__get_limit > fp->__bufp ? + fp->__get_limit - fp->__buffer : + buffer_written); + + if (fp->__io_funcs.__write == NULL || (to_write == 0 && flush_only)) + { + /* There is no writing function or we're coming from an fflush + call with nothing in the buffer, so just say the buffer's + been flushed, increment the file offset, and return. */ + fp->__bufp = fp->__buffer; + fp->__offset += to_write; + goto end; + } + + if (to_write > 0) + { + int wrote; + + /* Go to the target file position. Don't bother if appending; + the write will just ignore the file position anyway. */ + if (!fp->__mode.__append) + seek_to_target (fp); + + if (!ferror(fp)) + { + /* Write out the buffered data. */ + wrote = (*fp->__io_funcs.__write)(fp->__cookie, fp->__buffer, + to_write); + if (wrote > 0) + { + if (fp->__mode.__append) + /* The write has written the data to the end of the file + and updated the file position to after the data. Don't + bother to find the current position; we can get it + later if we need it. */ + fp->__offset = fp->__target = -1; + else + /* Record that we've moved forward in the file. */ + fp->__offset += wrote; + } + if (wrote < (int) to_write) + /* The writing function should always write + the whole buffer unless there is an error. */ + fp->__error = 1; + } + } + + /* Reset the buffer pointer to the beginning of the buffer. */ + fp->__bufp = fp->__buffer; + + /* If we're not just flushing, write the last character, C. */ + if (!flush_only && !ferror(fp)) + { + if (fp->__buffer == NULL || (fp->__linebuf && (unsigned char) c == '\n')) + { + /* Either we're unbuffered, or we're line-buffered and + C is a newline, so really write it out immediately. */ + char cc = (unsigned char) c; + if ((*fp->__io_funcs.__write)(fp->__cookie, &cc, 1) < 1) + fp->__error = 1; + else + { + /* Record that we've moved forward in the file. */ + ++fp->__offset; + ++fp->__target; + } + } + else + /* Just put C in the buffer. */ + *fp->__bufp++ = (unsigned char) c; + } + + end: + + if (!twiddled) + { + /* The new target position moves up as + much as the user wrote into the buffer. */ + fp->__target += buffer_written; + + /* Set the reading limit to the beginning of the buffer, + so the next `getc' will call __fillbf. */ + fp->__get_limit = fp->__buffer; + } + + if (feof(fp) || ferror(fp)) + fp->__bufp = fp->__put_limit; +} + + +/* Fill the buffer for FP and return the first character read (or EOF). + This is the default `input_room' function. */ +static int +DEFUN(fillbuf, (fp), register FILE *fp) +{ + /* How far into the buffer we read we want to start bufp. */ + size_t buffer_offset = 0; + register char *buffer; + register size_t to_read, nread = 0; + /* This must be unsigned to avoid sign extension in return. */ + unsigned char c; + + if (fp->__io_funcs.__read == NULL) + { + /* There is no read function, so always return EOF. */ + fp->__eof = 1; + goto end; + } + + if (fp->__buffer == NULL) + { + /* We're unbuffered, so we want to read only one character. */ + buffer = (char *) &c; + to_read = 1; + } + else + { + /* We're buffered, so try to fill the buffer. */ + buffer = fp->__buffer; + to_read = fp->__bufsize; + } + + /* We're reading, so we're not at the end-of-file. */ + fp->__eof = 0; + + /* Go to the target file position. */ + { + int save = errno; + if (__stdio_check_offset (fp) == 0 && fp->__target != fp->__offset) + { + /* Move to a block (buffer size) boundary. */ + if (fp->__bufsize != 0) + { + buffer_offset = fp->__target % fp->__bufsize; + fp->__target -= buffer_offset; + } + seek_to_target (fp); + } + errno = save; + } + + while (!ferror(fp) && !feof(fp) && nread <= buffer_offset) + { + /* Try to fill the buffer. */ + int count = (*fp->__io_funcs.__read)(fp->__cookie, buffer, to_read); + if (count == 0) + fp->__eof = 1; + else if (count < 0) + fp->__error = 1; + else + { + buffer += count; + nread += count; + to_read -= count; + /* Record that we've moved forward in the file. */ + fp->__offset += count; + } + } + + if (fp->__buffer == NULL) + /* There is no buffer, so return the character we read + without all the buffer pointer diddling. */ + return (feof(fp) || ferror(fp)) ? EOF : c; + + /* Reset the buffer pointer to the beginning of the buffer + (plus whatever offset we may have set above). */ + fp->__bufp = fp->__buffer + buffer_offset; + + end:; + + if (feof(fp) || ferror(fp)) + { + /* Set both end pointers to the beginning of the buffer so + the next i/o call will force a call to __fillbf/__flshfp. */ + fp->__put_limit = fp->__get_limit = fp->__buffer; + return EOF; + } + + /* Set the end pointer to one past the last character we read. */ + fp->__get_limit = fp->__buffer + nread; + + /* Make it so the next `putc' will call __flshfp. */ + fp->__put_limit = fp->__buffer; + + /* Return the first character in the buffer. */ + return *((unsigned char *) (fp->__bufp++)); +} + + +/* Default I/O and room functions. */ + +extern __io_read_fn __stdio_read; +extern __io_write_fn __stdio_write; +extern __io_seek_fn __stdio_seek; +extern __io_close_fn __stdio_close; +extern __io_fileno_fn __stdio_fileno; +CONST __io_functions __default_io_functions = + { + __stdio_read, __stdio_write, __stdio_seek, __stdio_close, __stdio_fileno + }; + +CONST __room_functions __default_room_functions = + { + fillbuf, flushbuf + }; + + +/* Flush the buffer for FP and also write C if FLUSH_ONLY is nonzero. + This is the function used by putc and fflush. */ +int +DEFUN(__flshfp, (fp, c), + register FILE *fp AND int c) +{ + int flush_only = c == EOF; + + if (!__validfp(fp) || !fp->__mode.__write) + { + errno = EINVAL; + return EOF; + } + + if (ferror(fp)) + return EOF; + + if (fp->__pushed_back) + { + /* Discard the char pushed back by ungetc. */ + fp->__bufp = fp->__pushback_bufp; + fp->__pushed_back = 0; + } + + /* Make sure the stream is initialized (has functions and buffering). */ + init_stream(fp); + + /* Do this early, so a `putc' on such a stream will never return success. */ + if (fp->__room_funcs.__output == NULL) + { + /* A NULL `output room' function means + to always return an output error. */ + fp->__error = 1; + return EOF; + } + + if (!flush_only && + /* Will C fit into the buffer? + See below about linebuf_active. */ + fp->__bufp < (fp->__linebuf_active ? fp->__buffer + fp->__bufsize : + fp->__put_limit)) + { + /* The character will fit in the buffer, so put it there. */ + *fp->__bufp++ = (unsigned char) c; + if (fp->__linebuf && (unsigned char) c == '\n') + flush_only = 1; + else + return (unsigned char) c; + } + + if (fp->__linebuf_active) + /* This is an active line-buffered stream, so its put-limit is set + to the beginning of the buffer in order to force a __flshfp call + on each putc (see below). We undo this hack here (by setting + the limit to the end of the buffer) to simplify the interface + with the output-room function. */ + fp->__put_limit = fp->__buffer + fp->__bufsize; + + /* Make room in the buffer. */ + (*fp->__room_funcs.__output) (fp, flush_only ? EOF : (unsigned char) c); + + if (fp->__linebuf) + { + /* This is a line-buffered stream, and it is now ready to do + some output. We call this an "active line-buffered stream". + We set the put_limit to the beginning of the buffer, + so the next `putc' call will force a call to this function. + Setting the linebuf_active flag tells the code above + (on the next call) to undo this hackery. */ + fp->__put_limit = fp->__buffer; + fp->__linebuf_active = 1; + } + + if (ferror (fp)) + return EOF; + if (flush_only) + return 0; + return (unsigned char) c; +} + + +/* Fill the buffer for FP and return the first character read. + This is the function used by getc. */ +int +DEFUN(__fillbf, (fp), register FILE *fp) +{ + register int c; + fpos_t new_target; + + if (!__validfp(fp) || !fp->__mode.__read) + { + errno = EINVAL; + return EOF; + } + + if (fp->__pushed_back) + { + /* Return the char pushed back by ungetc. */ + fp->__bufp = fp->__pushback_bufp; + fp->__pushed_back = 0; + return fp->__pushback; + } + + /* Make sure the stream is initialized (has functions and buffering). */ + init_stream(fp); + + /* If we're trying to read the first character of a new + line of input from an unbuffered or line buffered stream, + we must flush all line-buffered output streams. */ + if (fp->__buffer == NULL || fp->__linebuf) + { + register FILE *f; + for (f = __stdio_head; f != NULL; f = f->__next) + if (__validfp (f) && f->__linebuf && f->__mode.__write) + (void) __flshfp (f, EOF); + } + + /* Note we must do this after flushing all line-buffered + streams, or else __flshfp would undo it! */ + if (fp->__linebuf_active) + { + /* This is an active line-buffered stream, meaning it is in the midst + of writing, but has a bogus put_limit. Restore it to normality. */ + fp->__put_limit = fp->__buffer + fp->__bufsize; + fp->__linebuf_active = 0; + } + + /* We want the beginning of the buffer to now + map to just past the last data we read. */ + new_target = fp->__target + (fp->__get_limit - fp->__buffer); + + if (fp->__put_limit > fp->__buffer) + { + /* There is written data in the buffer. + Flush it out. */ + if (fp->__room_funcs.__output == NULL) + fp->__error = 1; + else + (*fp->__room_funcs.__output) (fp, EOF); + } + + fp->__target = new_target; + + if (ferror(fp)) + c = EOF; + else if (fp->__room_funcs.__input != NULL) + { + c = (*fp->__room_funcs.__input)(fp); + if (fp->__buffer == NULL) + /* This is an unbuffered stream, so the target sync above + won't do anything the next time around. Instead, note that + we have read one character. The (nonexistent) buffer now + maps to the position just past that character. */ + ++fp->__target; + } + else + { + /* A NULL `input_room' function means always return EOF. */ + fp->__eof = 1; + c = EOF; + } + + return c; +} + + +/* Nuke a stream, but don't kill its link in the chain. */ +void +DEFUN(__invalidate, (stream), register FILE *stream) +{ + /* Save its link. */ + register FILE *next = stream->__next; + + /* Pulverize the fucker. */ + memset((PTR) stream, 0, sizeof(FILE)); + + /* Restore the deceased's link. */ + stream->__next = next; +} |