diff options
| -rw-r--r-- | io/fcntl.h | 126 | ||||
| -rw-r--r-- | io/sys/stat.h | 153 | ||||
| -rw-r--r-- | stdio/internals.c | 596 | ||||
| -rw-r--r-- | sys/stat.h | 1 | ||||
| -rw-r--r-- | sysdeps/unix/bsd/fcntlbits.h | 59 |
5 files changed, 935 insertions, 0 deletions
diff --git a/io/fcntl.h b/io/fcntl.h new file mode 100644 index 0000000000..894c3d4416 --- /dev/null +++ b/io/fcntl.h @@ -0,0 +1,126 @@ +/* Copyright (C) 1991, 1992 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. */ + +/* + * POSIX Standard: 6.5 File Control Operations <fcntl.h> + */ + +#ifndef _FCNTL_H + +#define _FCNTL_H 1 +#include <features.h> + +#include <gnu/fcntl.h> +#include <filebits.h> + + +/* Values for the second argument to fcntl. */ +#define F_DUPFD __F_DUPFD /* Duplicate file descriptor. */ +#define F_GETFD __F_GETFD /* Get file descriptor flags. */ +#define F_SETFD __F_SETFD /* Set file descriptor flags. */ +#define F_GETFL __F_GETFL /* Get file status flags. */ +#define F_SETFL __F_SETFL /* Set file status flags. */ +#define F_SETLK __F_SETLK /* Set record locking info. */ +#define F_SETLKW __F_SETLKW /* Set record locking, block. */ + +#ifdef __USE_BSD +#define F_GETOWN __F_GETOWN /* Get owner (receiver of SIGIO). */ +#define F_SETOWN __F_SETOWN /* Set owner (receiver of SIGIO). */ +#endif + + +/* File descriptor flags used with F_GETFD and F_SETFD. */ +#define FD_CLOEXEC __FD_CLOEXEC /* Close on exec. */ + + +/* File access modes for open and fcntl. */ +#define O_RDONLY __O_RDONLY /* Open read-only. */ +#define O_WRONLY __O_WRONLY /* Open write-only. */ +#define O_RDWR __O_RDWR /* Open read/write. */ + + +/* Bits OR'd into the second argument to open. */ +#define O_CREAT __O_CREAT /* Create file if it doesn't exist. */ +#define O_EXCL __O_EXCL /* Fail if file already exists. */ +#define O_TRUNC __O_TRUNC /* Truncate file to zero length. */ +#define O_NOCTTY __O_NOCTTY /* Don't assign a controlling tty. */ + + +/* File status flags for `open' and `fcntl'. */ +#define O_APPEND __O_APPEND /* Writes append to the file. */ +#define O_NONBLOCK __O_NONBLOCK /* No delay when opening the file. */ + +#ifdef __USE_BSD +#define O_NDELAY __O_NDELAY +#endif + +#ifdef __USE_MISC +/* Unix-style flags for `fcntl' F_GETFL and F_SETFL. */ +#define FREAD 0x1 /* Read access. */ +#define FWRITE 0x2 /* Write access. */ +#define FNDELAY O_NONBLOCK +#define FAPPEND O_APPEND +#define FASYNC 0x40 /* Send SIGIO when data is ready. */ +#define FCREAT O_CREAT +#define FTRUNC O_TRUNC +#define FEXCL O_EXCL +#define FSYNC 0x2000 /* Synchronous writes. */ + +#ifndef R_OK /* Verbatim from <unistd.h>. Ugh. */ +/* Values for the second argument to access. + These may be OR'd together. */ +#define R_OK 4 /* Test for read permission. */ +#define W_OK 2 /* Test for write permission. */ +#define X_OK 1 /* Test for execute permission. */ +#define F_OK 0 /* Test for existence. */ +#endif +#endif /* Use misc. */ + + +/* Mask for file access modes. */ +#define O_ACCMODE __O_ACCMODE + + +/* Do the file control operation described by CMD on FD. + The remaining arguments are interpreted depending on CMD. */ +extern int EXFUN(__fcntl, (int __fd, int __cmd, ...)); + +/* Open FILE and return a new file descriptor for it, or -1 on error. + OFLAG determines the type of access used. If O_CREAT is on OFLAG, + the third argument is taken as a `mode_t', the mode of the created file. */ +extern int EXFUN(__open, (CONST char *__file, int __oflag, ...)); + +#define fcntl __fcntl +#define open __open + +/* Create and open FILE, with mode MODE. + This takes an `int' MODE argument because that is + what `mode_t' will be widened to. */ +extern int EXFUN(creat, (CONST char *__file, __mode_t __mode)); + +#ifdef __OPTIMIZE__ +#define creat(file, m) __open((file), O_WRONLY|O_CREAT|O_TRUNC, (m)) +#endif /* Optimizing. */ + +#define flock __flock +#define F_RDLCK __F_RDLCK +#define F_WRLCK __F_WRLCK +#define F_UNLCK __F_UNLCK + + +#endif /* fcntl.h */ diff --git a/io/sys/stat.h b/io/sys/stat.h new file mode 100644 index 0000000000..7e86f73c6f --- /dev/null +++ b/io/sys/stat.h @@ -0,0 +1,153 @@ +/* Copyright (C) 1991 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. */ + +/* + * POSIX Standard: 5.6 File Characteristics <sys/stat.h> + */ + +#ifndef _SYS_STAT_H + +#define _SYS_STAT_H 1 +#include <features.h> + +#include <gnu/stat.h> + +#if defined(__USE_BSD) || defined(__USE_MISC) +#define S_IFMT __S_IFMT +#define S_IFDIR __S_IFDIR +#define S_IFCHR __S_IFCHR +#define S_IFBLK __S_IFBLK +#define S_IFREG __S_IFREG +#define S_IFLNK __S_IFLNK +#define S_IFSOCK __S_IFSOCK +#define S_IFIFO __S_IFIFO +#endif + +/* Test macros for file types. */ + +#define __S_ISTYPE(mode, mask) (((mode) & __S_IFMT) == (mask)) + +#define S_ISDIR(mode) __S_ISTYPE((mode), __S_IFDIR) +#define S_ISCHR(mode) __S_ISTYPE((mode), __S_IFCHR) +#define S_ISBLK(mode) __S_ISTYPE((mode), __S_IFBLK) +#define S_ISREG(mode) __S_ISTYPE((mode), __S_IFREG) +#define S_ISFIFO(mode) __S_ISTYPE((mode), __S_IFIFO) + +#ifdef __USE_GNU +#define S_ISLNK(mode) __S_ISTYPE((mode), __S_IFLNK) +#define S_ISSOCK(mode) __S_ISTYPE((mode), __S_IFSOCK) +#endif + + +/* Protection bits. */ + +#define S_ISUID __S_ISUID/* Set user ID on execution. */ +#define S_ISGID __S_ISGID/* Set group ID on execution. */ + +#if defined(__USE_BSD) || defined(__USE_MISC) +#define S_ISVTX __S_ISVTX/* Save swapped text after use (sticky bit). */ +#endif + +#define S_IRUSR __S_IREAD /* Read by owner. */ +#define S_IWUSR __S_IWRITE /* Write by owner. */ +#define S_IXUSR __S_IEXEC /* Execute by owner. */ +/* Read, write, and execute by owner. */ +#define S_IRWXU (__S_IREAD|__S_IWRITE|__S_IEXEC) + +#if defined(__USE_MISC) && defined(__USE_BSD) +#define S_IREAD S_IRUSR +#define S_IWRITE S_IWUSR +#define S_IEXEC S_IXUSR +#endif + +#define S_IRGRP (S_IRUSR >> 3) /* Read by group. */ +#define S_IWGRP (S_IWUSR >> 3) /* Write by group. */ +#define S_IXGRP (S_IXUSR >> 3) /* Execute by group. */ +/* Read, write, and execute by group. */ +#define S_IRWXG (S_IRWXU >> 3) + +#define S_IROTH (S_IRGRP >> 3) /* Read by others. */ +#define S_IWOTH (S_IWGRP >> 3) /* Write by others. */ +#define S_IXOTH (S_IXGRP >> 3) /* Execute by others. */ +/* Read, write, and execute by others. */ +#define S_IRWXO (S_IRXWG >> 3) + + +/* Get file attributes for FILE and put them in BUF. */ +extern int EXFUN(__stat, (CONST char *__file, struct __stat *__buf)); + +/* Get file attributes for the file, device, pipe, or socket + that file descriptor FD is open on and put them in BUF. */ +extern int EXFUN(__fstat, (int __fd, struct __stat *__buf)); + +/* Get file attributes about FILE and put them in BUF. + If FILE is a symbolic link, do not follow it. */ +extern int EXFUN(__lstat, (CONST char *__file, struct __stat *__buf)); + +/* Set file access permissions for FILE to MODE. + This takes an `int' MODE argument because that + is what `mode_t's get widened to. */ +extern int EXFUN(__chmod, (CONST char *__file, __mode_t __mode)); + +/* Set file access permissions of the file FD is open on to MODE. */ +extern int EXFUN(__fchmod, (int __fd, int __mode)); + + +/* Set the file creation mask of the current process to MASK, + and return the old creation mask. */ +extern __mode_t EXFUN(__umask, (__mode_t __mask)); + +#ifdef __USE_GNU +/* Get the current `umask' value without changing it. + This function is only available under the GNU Hurd. */ +extern __mode_t EXFUN(getumask, (NOARGS)); +#endif + +/* Create a new directory named PATH, with permission bits MODE. */ +extern int EXFUN(__mkdir, (CONST char *__path, __mode_t __mode)); + +/* Create a device file named PATH, with permission and special bits MODE + and device number DEV (which can be constructed from major and minor + device numbers with the `makedev' macro above). */ +extern int EXFUN(__mknod, (CONST char *__path, int __mode, int __dev)); + + +#define stat __stat +#define fstat __fstat + +#ifdef __USE_BSD +#define lstat __lstat +#endif /* Use BSD. */ + +#define chmod __chmod + +#ifdef __USE_BSD +#define fchmod __fchmod +#endif + +#define umask __umask +#define mkdir __mkdir + +/* Create a new FIFO named PATH, with permission bits MODE. */ +extern int EXFUN(mkfifo, (CONST char *__path, __mode_t __mode)); + +#if defined(__USE_MISC) || defined(__USE_BSD) +#define mknod __mknod +#endif + +#endif /* sys/stat.h */ diff --git a/stdio/internals.c b/stdio/internals.c new file mode 100644 index 0000000000..ade9c96171 --- /dev/null +++ b/stdio/internals.c @@ -0,0 +1,596 @@ +/* Copyright (C) 1991 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> + + +/* 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) +{ + 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; + } + + 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) +{ + 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) +{ + 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 to_write; + int target_set = 0; + + if (fp->__put_limit == fp->__buffer) + { + /* The stream needs to be primed for writing. */ + + size_t buffer_offset = 0; + + if (fp->__mode.__read && fp->__room_funcs.__input != NULL) + { + int save = errno; + CONST int aligned = (__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. */ + target_set = 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) + { + *fp->__bufp++ = (unsigned char) c; + if (!fp->__linebuf || (unsigned char) c != '\n') + return; + flush_only = 1; + } + } + } + + /* 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. */ + to_write = (fp->__get_limit > fp->__bufp ? + fp->__get_limit - fp->__buffer : + fp->__bufp - fp->__buffer); + + 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. */ + 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) + /* 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; + } + else + /* Just put C in the buffer. */ + *fp->__bufp++ = (unsigned char) c; + } + + end:; + + if (!target_set) + /* The beginning of the buffer now maps to + just past the data we have just written. */ + fp->__target = fp->__offset; + + if (!fp->__mode.__write) + /* 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; + 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 = &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; + + if (fp->__mode.__write) + /* Allow writing into the buffer. */ + fp->__put_limit = fp->__buffer + fp->__bufsize; + else + /* 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 __stdio_read; +extern __io_write __stdio_write; +extern __io_seek __stdio_seek; +extern __io_close __stdio_close; +CONST __io_functions __default_io_functions = + { + __stdio_read, __stdio_write, __stdio_seek, __stdio_close + }; + +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; + + /* Make sure the stream is initialized (has functions and buffering). */ + init_stream(fp); + + if (!flush_only && fp->__get_limit == fp->__buffer && + fp->__bufp > fp->__buffer && fp->__bufp < fp->__buffer + fp->__bufsize) + { + /* 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->__room_funcs.__output == NULL) + { + /* A NULL `output room' function means + to always return an output error. */ + fp->__error = 1; + return EOF; + } + + if (!flush_only || fp->__bufp > fp->__buffer) + { + if (fp->__linebuf && fp->__bufp > fp->__buffer) + /* This is a 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. We undo this hack here + (by setting the limit to the end of the buffer) to simplify + the interface with the output-room function. + However, we must make sure we don't do this if there isn't + actually anything in the buffer, because in that case we + want to give the output-room function a chance to prime + the stream for writing in whatever fashion turns it on. */ + 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) + /* Set the end pointer to the beginning of the buffer, + so the next `putc' call will force a call to this function + (see comment above about line-buffered streams). */ + fp->__put_limit = fp->__buffer; + } + + 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; + + 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 && + f->__put_limit > f->__buffer) + (void) __flshfp(f, EOF); + } + + 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 + { + fpos_t target = fp->__target; + (*fp->__room_funcs.__output)(fp, EOF); + fp->__target = target; + } + } + + /* We want the beginning of the buffer to now + map to just past the last data we read. */ + fp->__target += fp->__get_limit - fp->__buffer; + + 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; +} + + +/* Abort with an error message. */ +__NORETURN +void +DEFUN(__libc_fatal, (message), CONST char *message) +{ + __stdio_errmsg(message, strlen(message)); + abort(); +} diff --git a/sys/stat.h b/sys/stat.h new file mode 100644 index 0000000000..37a526069f --- /dev/null +++ b/sys/stat.h @@ -0,0 +1 @@ +#include <io/sys/stat.h> diff --git a/sysdeps/unix/bsd/fcntlbits.h b/sysdeps/unix/bsd/fcntlbits.h new file mode 100644 index 0000000000..61f2b64620 --- /dev/null +++ b/sysdeps/unix/bsd/fcntlbits.h @@ -0,0 +1,59 @@ +/* Copyright (C) 1991 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. */ + +#ifndef _GNU_FCNTL_H + +#define _GNU_FCNTL_H 1 + + +#include <gnu/types.h> + + +/* Values for the second argument to fcntl. */ +#define __F_DUPFD 0 /* Duplicate file descriptor. */ +#define __F_GETFD 1 /* Get file descriptor flags. */ +#define __F_SETFD 2 /* Set file descriptor flags. */ +#define __F_GETFL 3 /* Get file status flags. */ +#define __F_SETFL 4 /* Set file status flags. */ +#define __F_GETOWN 5 /* Get owner (receiver of SIGIO). */ +#define __F_SETOWN 6 /* Set owner (receiver of SIGIO). */ +#define __F_GETLK 7 /* Get record locking info. */ +#define __F_SETLK 8 /* Set record locking info. */ +#define __F_SETLKW 9 /* Set record locking info, wait. */ + +/* File descriptor flags used with F_GETFD and F_SETFD. */ +#define __FD_CLOEXEC 1 /* Close on exec. */ + + +/* The structure describing an advisory lock. This is the type of the third + argument to `fcntl' for the F_GETLK, F_SETLK, and F_SETLKW requests. */ +struct __flock + { + short int l_type; /* Type of lock: F_RDLCK, F_WRLCK, or F_UNLCK. */ + short int l_whence; /* Where `l_start' is relative to (like `lseek'). */ + __off_t l_start; /* Offset where the lock begins. */ + __off_t l_len; /* Size of the locked area; zero means until EOF. */ + __pid_t l_pid; /* Process holding the lock. */ + }; + +#define __F_RDLCK 1 /* Read lock. */ +#define __F_WRLCK 2 /* Write lock. */ +#define __F_UNLCK 3 /* Remove lock. */ + + +#endif /* gnu/fcntl.h */ |