-/* Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
-This file is part of the GNU C Library.
+/* Copyright (C) 1991, 92, 93, 94, 95, 96, 97 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 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.
+ 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. */
+ 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., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
-#include <ansidecl.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-/* 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)
+/* Make sure that FP has its functions set. */
+void
+__stdio_check_funcs (register FILE *fp)
{
if (!fp->__seen)
{
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 *));
+ extern void __stdio_init_stream __P ((FILE *));
fp->__room_funcs = __default_room_functions;
fp->__io_funcs = __default_io_functions;
- __stdio_init_stream(fp);
+ __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
+init_stream (register FILE *fp)
+{
+ __stdio_check_funcs (fp);
if (fp->__buffer == NULL && !fp->__userbuf)
{
save = errno;
while (fp->__bufsize >= MIN_BUFSIZE)
{
- fp->__buffer = (char *) malloc(fp->__bufsize);
+ fp->__buffer = (char *) malloc (fp->__bufsize);
if (fp->__buffer == NULL)
fp->__bufsize /= 2;
else
break;
}
- errno = save;
+ __set_errno (save);
if (fp->__buffer == NULL)
{
/* Determine the current file position of STREAM if it is unknown. */
int
-DEFUN(__stdio_check_offset, (stream), FILE *stream)
+__stdio_check_offset (stream)
+ FILE *stream;
{
init_stream (stream);
if (stream->__io_funcs.__seek == NULL)
{
/* Unknowable. */
- errno = ESPIPE;
+ __set_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 ((*stream->__io_funcs.__seek) (stream->__cookie,
+ &pos, SEEK_CUR) < 0)
{
if (errno == ESPIPE)
/* Object is incapable of seeking. */
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)
+seek_to_target (FILE *fp)
{
int save = errno;
if (__stdio_check_offset (fp) == EOF)
{
if (errno == ESPIPE)
- errno = save;
+ __set_errno (save);
else
fp->__error = 1;
}
if (fp->__io_funcs.__seek == NULL)
{
/* We can't seek! */
- errno = ESPIPE;
+ __set_errno (ESPIPE);
fp->__error = 1;
}
else
{
fpos_t pos = fp->__target;
- if ((*fp->__io_funcs.__seek)(fp->__cookie, &pos, SEEK_SET) < 0)
+ 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;
+ {
+ /* Seek didn't go to the right place!
+ This should never happen. */
+#ifdef EGRATUITOUS
+ /* It happens in the Hurd when the io server doesn't
+ obey the protocol for io_seek. */
+ __set_errno (EGRATUITOUS);
+#else
+ /* I don't think this can happen in Unix. */
+ __set_errno (ESPIPE); /* ??? */
+#endif
+ fp->__error = 1;
+ }
}
}
}
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)
+flushbuf (register FILE *fp, int c)
{
int flush_only = c == EOF;
size_t buffer_written;
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->__target == -1)
+ /* For an unseekable object, data recently read bears no relation
+ to data we will write later. Discard the buffer. */
+ fp->__get_limit = fp->__buffer;
+ else
+ /* 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 = (__stdio_check_offset(fp) == EOF ||
+ const int aligned = (fp->__buffer == NULL ||
+ __stdio_check_offset (fp) == EOF ||
fp->__target % fp->__bufsize == 0);
- errno = save;
+ __set_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;
+ const size_t o = fp->__target % fp->__bufsize;
fp->__target -= o;
- if ((*fp->__room_funcs.__input)(fp) == EOF && ferror(fp))
+ if ((*fp->__room_funcs.__input) (fp) == EOF && ferror (fp))
return;
else
- __clearerr(fp);
+ __clearerr (fp);
- if (fp->__get_limit - fp->__buffer < o)
+ if ((size_t) (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;
/* 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;
+ /* 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)
flush_only = 1;
}
}
+
+ if ((size_t) (fp->__bufp - fp->__buffer) <= buffer_offset && flush_only)
+ {
+ /* 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,
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;
+ if (fp->__offset != -1)
+ fp->__offset += to_write;
goto end;
}
if (!ferror(fp))
{
/* Write out the buffered data. */
- wrote = (*fp->__io_funcs.__write)(fp->__cookie, fp->__buffer,
- to_write);
+ wrote = (*fp->__io_funcs.__write) (fp->__cookie, fp->__buffer,
+ to_write);
if (wrote > 0)
{
if (fp->__mode.__append)
bother to find the current position; we can get it
later if we need it. */
fp->__offset = fp->__target = -1;
- else
+ else if (fp->__offset != -1)
/* Record that we've moved forward in the file. */
fp->__offset += wrote;
}
fp->__bufp = fp->__buffer;
/* If we're not just flushing, write the last character, C. */
- if (!flush_only && !ferror(fp))
+ if (!flush_only && !ferror (fp))
{
if (fp->__buffer == NULL || (fp->__linebuf && (unsigned char) c == '\n'))
{
char cc = (unsigned char) c;
if ((*fp->__io_funcs.__write)(fp->__cookie, &cc, 1) < 1)
fp->__error = 1;
- else
+ else if (fp->__offset != -1)
{
/* Record that we've moved forward in the file. */
++fp->__offset;
if (!twiddled)
{
- /* The new target position moves up as
- much as the user wrote into the buffer. */
- fp->__target += buffer_written;
+ if (fp->__target != -1)
+ /* 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))
+ 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)
+fillbuf (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;
- char c;
+ /* This must be unsigned to avoid sign extension in return. */
+ unsigned char c;
if (fp->__io_funcs.__read == NULL)
{
if (fp->__buffer == NULL)
{
/* We're unbuffered, so we want to read only one character. */
- buffer = &c;
+ buffer = (char *) &c;
to_read = 1;
}
else
}
seek_to_target (fp);
}
- errno = save;
+ __set_errno (save);
}
- while (!ferror(fp) && !feof(fp) && nread <= buffer_offset)
+ while (!ferror (fp) && !feof (fp) && nread <= buffer_offset)
{
/* Try to fill the buffer. */
- int count = (*fp->__io_funcs.__read)(fp->__cookie, buffer, to_read);
+ int count = (*fp->__io_funcs.__read) (fp->__cookie, buffer, to_read);
if (count == 0)
fp->__eof = 1;
else if (count < 0)
buffer += count;
nread += count;
to_read -= count;
- /* Record that we've moved forward in the file. */
- fp->__offset += count;
+ if (fp->__offset != -1)
+ /* 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;
+ 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). */
end:;
- if (feof(fp) || ferror(fp))
+ 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->__buffer;
/* Return the first character in the buffer. */
- return (unsigned char) *fp->__bufp++;
+ return *((unsigned char *) (fp->__bufp++));
}
/* Default I/O and room functions. */
-extern __io_read __stdio_read;
-extern __io_write __stdio_write;
-extern __io_seek __stdio_seek;
-extern __io_close __stdio_close;
-CONST __io_functions __default_io_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 =
+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)
+__flshfp (fp, c)
+ register FILE *fp;
+ int c;
{
int flush_only = c == EOF;
- if (!__validfp(fp) || !fp->__mode.__write)
+ if (!__validfp (fp) || !fp->__mode.__write)
{
- errno = EINVAL;
+ __set_errno (EINVAL);
return EOF;
}
- if (ferror(fp))
+ if (ferror (fp))
return EOF;
if (fp->__pushed_back)
}
/* Make sure the stream is initialized (has functions and buffering). */
- init_stream(fp);
+ init_stream (fp);
/* Do this early, so a `putc' on such a stream will never return success. */
if (fp->__room_funcs.__output == NULL)
/* 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)
+__fillbf (fp)
+ register FILE *fp;
{
register int c;
fpos_t new_target;
- if (!__validfp(fp) || !fp->__mode.__read)
+ if (!__validfp (fp) || !fp->__mode.__read)
{
- errno = EINVAL;
+ __set_errno (EINVAL);
return EOF;
}
}
/* Make sure the stream is initialized (has functions and buffering). */
- init_stream(fp);
+ 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,
fp->__target = new_target;
- if (ferror(fp))
+ if (ferror (fp))
c = EOF;
else if (fp->__room_funcs.__input != NULL)
{
- c = (*fp->__room_funcs.__input)(fp);
+ 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
/* Nuke a stream, but don't kill its link in the chain. */
void
-DEFUN(__invalidate, (stream), register FILE *stream)
+__invalidate (stream)
+ register FILE *stream;
{
/* Save its link. */
register FILE *next = stream->__next;
- /* Pulverize the fucker. */
- memset((PTR) stream, 0, sizeof(FILE));
+ /* Pulverize the deceased. */
+ memset((void *) stream, 0, sizeof(FILE));
/* Restore the deceased's link. */
stream->__next = next;
projects / kopensolaris-gnu / glibc.git / blobdiff