2018-02-21 Zack Weinberg <zackw@panix.com>
+ * libio/libio.h (_IOS_ATEND, _IOS_APPEND, _IOS_TRUNC)
+ (_IOS_NOCREATE, _IOS_NOREPLACE, _IOS_BIN, _OLD_STDIO_MAGIC)
+ (_IO_SKIPWS, _IO_LEFT, _IO_RIGHT, _IO_INTERNAL, _IO_DEC)
+ (_IO_OCT, _IO_HEX, _IO_SHOWBASE, _IO_SHOWPOINT, _IO_UPPERCASE)
+ (_IO_SHOWPOS, _IO_SCIENTIFIC, _IO_FIXED, _IO_UNITBUF, _IO_STDIO)
+ (_IO_DONT_CLOSE, _IO_BOOLALPHA, _IO_BAD_SEEN): Remove, unused.
+ Reformat bit flags for _flags field to make occupancy clearer.
+ Update commentary.
+ * libio/bits/types/struct_FILE.h (_IO_EOF_SEEN, _IO_ERR_SEEN):
+ Keep definitions consistent with those in libio/libio.h.
+
+ * libio/libio.h (_IO_file_flags): Remove macro.
+ All uses changed to _flags.
+
* libio/libio.h (_IO_UNIFIED_JUMPTABLES, _STDIO_USES_IOSTREAM)
(__HAVE_COLUMN, _IO_BE): Don't define.
(_IO_peekc_unlocked, _IO_getwc_unlocked, _IO_putwc_unlocked)
/* This is very tricky since a file descriptor may be in the
non-blocking mode. The error flag doesn't mean much in this
case. We return an error only when there is a new error. */
- int old_error = fp->_IO_file_flags & _IO_ERR_SEEN;
- fp->_IO_file_flags &= ~_IO_ERR_SEEN;
+ int old_error = fp->_flags & _IO_ERR_SEEN;
+ fp->_flags &= ~_IO_ERR_SEEN;
count = _IO_getline (fp, buf, MIN ((size_t) n - 1, size), '\n', 1);
/* If we read in some bytes and errno is EAGAIN, that error will
be reported for next read. */
- if (count == 0 || ((fp->_IO_file_flags & _IO_ERR_SEEN)
- && errno != EAGAIN))
+ if (count == 0 || ((fp->_flags & _IO_ERR_SEEN) && errno != EAGAIN))
result = NULL;
else if (count >= size)
__chk_fail ();
buf[count] = '\0';
result = buf;
}
- fp->_IO_file_flags |= old_error;
+ fp->_flags |= old_error;
_IO_release_lock (fp);
return result;
}
/* This is very tricky since a file descriptor may be in the
non-blocking mode. The error flag doesn't mean much in this
case. We return an error only when there is a new error. */
- int old_error = fp->_IO_file_flags & _IO_ERR_SEEN;
- fp->_IO_file_flags &= ~_IO_ERR_SEEN;
+ int old_error = fp->_flags & _IO_ERR_SEEN;
+ fp->_flags &= ~_IO_ERR_SEEN;
count = _IO_getline (fp, buf, MIN ((size_t) n - 1, size), '\n', 1);
/* If we read in some bytes and errno is EAGAIN, that error will
be reported for next read. */
- if (count == 0 || ((fp->_IO_file_flags & _IO_ERR_SEEN)
- && errno != EAGAIN))
+ if (count == 0 || ((fp->_flags & _IO_ERR_SEEN) && errno != EAGAIN))
result = NULL;
else if (count >= size)
__chk_fail ();
buf[count] = '\0';
result = buf;
}
- fp->_IO_file_flags |= old_error;
+ fp->_flags |= old_error;
return result;
}
/* This is very tricky since a file descriptor may be in the
non-blocking mode. The error flag doesn't mean much in this
case. We return an error only when there is a new error. */
- old_error = fp->_IO_file_flags & _IO_ERR_SEEN;
- fp->_IO_file_flags &= ~_IO_ERR_SEEN;
+ old_error = fp->_flags & _IO_ERR_SEEN;
+ fp->_flags &= ~_IO_ERR_SEEN;
count = _IO_getwline (fp, buf, MIN ((size_t) n - 1, size), L'\n', 1);
/* If we read in some bytes and errno is EAGAIN, that error will
be reported for next read. */
buf[count] = '\0';
result = buf;
}
- fp->_IO_file_flags |= old_error;
+ fp->_flags |= old_error;
_IO_release_lock (fp);
return result;
}
/* This is very tricky since a file descriptor may be in the
non-blocking mode. The error flag doesn't mean much in this
case. We return an error only when there is a new error. */
- old_error = fp->_IO_file_flags & _IO_ERR_SEEN;
- fp->_IO_file_flags &= ~_IO_ERR_SEEN;
+ old_error = fp->_flags & _IO_ERR_SEEN;
+ fp->_flags &= ~_IO_ERR_SEEN;
count = _IO_getwline (fp, buf, MIN ((size_t) n - 1, size), L'\n', 1);
/* If we read in some bytes and errno is EAGAIN, that error will
be reported for next read. */
- if (count == 0 || ((fp->_IO_file_flags & _IO_ERR_SEEN)
- && errno != EAGAIN))
+ if (count == 0 || ((fp->_flags & _IO_ERR_SEEN) && errno != EAGAIN))
result = NULL;
else if (count >= size)
__chk_fail ();
buf[count] = '\0';
result = buf;
}
- fp->_IO_file_flags |= old_error;
+ fp->_flags |= old_error;
return result;
}
/* This is very tricky since a file descriptor may be in the
non-blocking mode. The error flag doesn't mean much in this
case. We return an error only when there is a new error. */
- int old_error = _IO_stdin->_IO_file_flags & _IO_ERR_SEEN;
- _IO_stdin->_IO_file_flags &= ~_IO_ERR_SEEN;
+ int old_error = _IO_stdin->_flags & _IO_ERR_SEEN;
+ _IO_stdin->_flags &= ~_IO_ERR_SEEN;
buf[0] = (char) ch;
count = _IO_getline (_IO_stdin, buf + 1, size - 1, '\n', 0) + 1;
- if (_IO_stdin->_IO_file_flags & _IO_ERR_SEEN)
+ if (_IO_stdin->_flags & _IO_ERR_SEEN)
{
retval = NULL;
goto unlock_return;
}
else
- _IO_stdin->_IO_file_flags |= old_error;
+ _IO_stdin->_flags |= old_error;
}
if (count >= size)
__chk_fail ();
? __overflow (_fp, (unsigned char) (_ch)) \
: (unsigned char) (*(_fp)->_IO_write_ptr++ = (_ch)))
-#define _IO_EOF_SEEN 0x10
+#define _IO_EOF_SEEN 0x0010
#define __feof_unlocked_body(_fp) (((_fp)->_flags & _IO_EOF_SEEN) != 0)
-#define _IO_ERR_SEEN 0x20
+#define _IO_ERR_SEEN 0x0020
#define __ferror_unlocked_body(_fp) (((_fp)->_flags & _IO_ERR_SEEN) != 0)
#define _IO_USER_LOCK 0x8000
of our file descriptor. Hence we actually don't know the actual
position before we do the first fseek (and until a following fflush). */
fp->file._offset = _IO_pos_BAD;
- fp->file._IO_file_flags |= CLOSED_FILEBUF_FLAGS;
+ fp->file._flags |= CLOSED_FILEBUF_FLAGS;
_IO_link_in (fp);
fp->file._fileno = -1;
#endif
/* First unlink the stream. */
- if (fp->_IO_file_flags & _IO_IS_FILEBUF)
+ if (fp->_flags & _IO_IS_FILEBUF)
_IO_un_link ((struct _IO_FILE_plus *) fp);
_IO_acquire_lock (fp);
- if (fp->_IO_file_flags & _IO_IS_FILEBUF)
+ if (fp->_flags & _IO_IS_FILEBUF)
status = _IO_file_close_it (fp);
else
status = fp->_flags & _IO_ERR_SEEN ? -1 : 0;
}
if (fp != _IO_stdin && fp != _IO_stdout && fp != _IO_stderr)
{
- fp->_IO_file_flags = 0;
+ fp->_flags = 0;
free(fp);
}
/* This is very tricky since a file descriptor may be in the
non-blocking mode. The error flag doesn't mean much in this
case. We return an error only when there is a new error. */
- old_error = fp->_IO_file_flags & _IO_ERR_SEEN;
- fp->_IO_file_flags &= ~_IO_ERR_SEEN;
+ old_error = fp->_flags & _IO_ERR_SEEN;
+ fp->_flags &= ~_IO_ERR_SEEN;
count = _IO_getline (fp, buf, n - 1, '\n', 1);
/* If we read in some bytes and errno is EAGAIN, that error will
be reported for next read. */
- if (count == 0 || ((fp->_IO_file_flags & _IO_ERR_SEEN)
- && errno != EAGAIN))
+ if (count == 0 || ((fp->_flags & _IO_ERR_SEEN) && errno != EAGAIN))
result = NULL;
else
{
buf[count] = '\0';
result = buf;
}
- fp->_IO_file_flags |= old_error;
+ fp->_flags |= old_error;
_IO_release_lock (fp);
return result;
}
/* This is very tricky since a file descriptor may be in the
non-blocking mode. The error flag doesn't mean much in this
case. We return an error only when there is a new error. */
- old_error = fp->_IO_file_flags & _IO_ERR_SEEN;
- fp->_IO_file_flags &= ~_IO_ERR_SEEN;
+ old_error = fp->_flags & _IO_ERR_SEEN;
+ fp->_flags &= ~_IO_ERR_SEEN;
count = _IO_getline (fp, buf, n - 1, '\n', 1);
/* If we read in some bytes and errno is EAGAIN, that error will
be reported for next read. */
- if (count == 0 || ((fp->_IO_file_flags & _IO_ERR_SEEN)
- && errno != EAGAIN))
+ if (count == 0 || ((fp->_flags & _IO_ERR_SEEN) && errno != EAGAIN))
result = NULL;
else
{
buf[count] = '\0';
result = buf;
}
- fp->_IO_file_flags |= old_error;
+ fp->_flags |= old_error;
return result;
}
libc_hidden_def (__fgets_unlocked)
/* This is very tricky since a file descriptor may be in the
non-blocking mode. The error flag doesn't mean much in this
case. We return an error only when there is a new error. */
- old_error = fp->_IO_file_flags & _IO_ERR_SEEN;
- fp->_IO_file_flags &= ~_IO_ERR_SEEN;
+ old_error = fp->_flags & _IO_ERR_SEEN;
+ fp->_flags &= ~_IO_ERR_SEEN;
count = _IO_getwline (fp, buf, n - 1, L'\n', 1);
/* If we read in some bytes and errno is EAGAIN, that error will
be reported for next read. */
buf[count] = '\0';
result = buf;
}
- fp->_IO_file_flags |= old_error;
+ fp->_flags |= old_error;
_IO_release_lock (fp);
return result;
}
/* This is very tricky since a file descriptor may be in the
non-blocking mode. The error flag doesn't mean much in this
case. We return an error only when there is a new error. */
- old_error = fp->_IO_file_flags & _IO_ERR_SEEN;
- fp->_IO_file_flags &= ~_IO_ERR_SEEN;
+ old_error = fp->_flags & _IO_ERR_SEEN;
+ fp->_flags &= ~_IO_ERR_SEEN;
count = _IO_getwline (fp, buf, n - 1, L'\n', 1);
/* If we read in some bytes and errno is EAGAIN, that error will
be reported for next read. */
- if (count == 0 || ((fp->_IO_file_flags & _IO_ERR_SEEN)
- && errno != EAGAIN))
+ if (count == 0 || ((fp->_flags & _IO_ERR_SEEN) && errno != EAGAIN))
result = NULL;
else
{
buf[count] = '\0';
result = buf;
}
- fp->_IO_file_flags |= old_error;
+ fp->_flags |= old_error;
return result;
}
/* This is very tricky since a file descriptor may be in the
non-blocking mode. The error flag doesn't mean much in this
case. We return an error only when there is a new error. */
- int old_error = _IO_stdin->_IO_file_flags & _IO_ERR_SEEN;
- _IO_stdin->_IO_file_flags &= ~_IO_ERR_SEEN;
+ int old_error = _IO_stdin->_flags & _IO_ERR_SEEN;
+ _IO_stdin->_flags &= ~_IO_ERR_SEEN;
buf[0] = (char) ch;
count = _IO_getline (_IO_stdin, buf + 1, INT_MAX, '\n', 0) + 1;
- if (_IO_stdin->_IO_file_flags & _IO_ERR_SEEN)
+ if (_IO_stdin->_flags & _IO_ERR_SEEN)
{
retval = NULL;
goto unlock_return;
}
else
- _IO_stdin->_IO_file_flags |= old_error;
+ _IO_stdin->_flags |= old_error;
}
buf[count] = 0;
retval = buf;
switch (mode)
{
case _IOFBF:
- fp->_IO_file_flags &= ~(_IO_LINE_BUF|_IO_UNBUFFERED);
+ fp->_flags &= ~(_IO_LINE_BUF|_IO_UNBUFFERED);
if (buf == NULL)
{
if (fp->_IO_buf_base == NULL)
result = EOF;
goto unlock_return;
}
- fp->_IO_file_flags &= ~_IO_LINE_BUF;
+ fp->_flags &= ~_IO_LINE_BUF;
}
result = 0;
goto unlock_return;
}
break;
case _IOLBF:
- fp->_IO_file_flags &= ~_IO_UNBUFFERED;
- fp->_IO_file_flags |= _IO_LINE_BUF;
+ fp->_flags &= ~_IO_UNBUFFERED;
+ fp->_flags |= _IO_LINE_BUF;
if (buf == NULL)
{
result = 0;
}
break;
case _IONBF:
- fp->_IO_file_flags &= ~_IO_LINE_BUF;
- fp->_IO_file_flags |= _IO_UNBUFFERED;
+ fp->_flags &= ~_IO_LINE_BUF;
+ fp->_flags |= _IO_UNBUFFERED;
buf = NULL;
size = 0;
break;
#include <shlib-compat.h>
-/* compatibility defines */
-#define _IO_file_flags _flags
-
-/* open modes */
+/* _IO_seekoff modes */
#define _IOS_INPUT 1
#define _IOS_OUTPUT 2
-#define _IOS_ATEND 4
-#define _IOS_APPEND 8
-#define _IOS_TRUNC 16
-#define _IOS_NOCREATE 32
-#define _IOS_NOREPLACE 64
-#define _IOS_BIN 128
-
-/* Magic numbers and bits for the _flags field.
- The magic numbers use the high-order bits of _flags;
- the remaining bits are available for variable flags.
- Note: The magic numbers must all be negative if stdio
- emulation is desired. */
-
-#define _IO_MAGIC 0xFBAD0000 /* Magic number */
-#define _OLD_STDIO_MAGIC 0xFABC0000 /* Emulate old stdio. */
-#define _IO_MAGIC_MASK 0xFFFF0000
-#define _IO_USER_BUF 1 /* User owns buffer; don't delete it on close. */
-#define _IO_UNBUFFERED 2
-#define _IO_NO_READS 4 /* Reading not allowed */
-#define _IO_NO_WRITES 8 /* Writing not allowd */
-#define _IO_EOF_SEEN 0x10
-#define _IO_ERR_SEEN 0x20
-#define _IO_DELETE_DONT_CLOSE 0x40 /* Don't call close(_fileno) on cleanup. */
-#define _IO_LINKED 0x80 /* Set if linked (using _chain) to streambuf::_list_all.*/
-#define _IO_IN_BACKUP 0x100
-#define _IO_LINE_BUF 0x200
-#define _IO_TIED_PUT_GET 0x400 /* Set if put and get pointer logicly tied. */
-#define _IO_CURRENTLY_PUTTING 0x800
-#define _IO_IS_APPENDING 0x1000
-#define _IO_IS_FILEBUF 0x2000
-#define _IO_BAD_SEEN 0x4000
-#define _IO_USER_LOCK 0x8000
+/* Magic number and bits for the _flags field. The magic number is
+ mostly vestigial, but preserved for compatibility. It occupies the
+ high 16 bits of _flags; the low 16 bits are actual flag bits. */
+
+#define _IO_MAGIC 0xFBAD0000 /* Magic number */
+#define _IO_MAGIC_MASK 0xFFFF0000
+#define _IO_USER_BUF 0x0001 /* Don't deallocate buffer on close. */
+#define _IO_UNBUFFERED 0x0002
+#define _IO_NO_READS 0x0004 /* Reading not allowed. */
+#define _IO_NO_WRITES 0x0008 /* Writing not allowed. */
+#define _IO_EOF_SEEN 0x0010
+#define _IO_ERR_SEEN 0x0020
+#define _IO_DELETE_DONT_CLOSE 0x0040 /* Don't call close(_fileno) on close. */
+#define _IO_LINKED 0x0080 /* In the list of all open files. */
+#define _IO_IN_BACKUP 0x0100
+#define _IO_LINE_BUF 0x0200
+#define _IO_TIED_PUT_GET 0x0400 /* Put and get pointer move in unison. */
+#define _IO_CURRENTLY_PUTTING 0x0800
+#define _IO_IS_APPENDING 0x1000
+#define _IO_IS_FILEBUF 0x2000
+ /* 0x4000 No longer used, reserved for compat. */
+#define _IO_USER_LOCK 0x8000
+
+/* Bits for the _flags2 field. */
#define _IO_FLAGS2_MMAP 1
#define _IO_FLAGS2_NOTCANCEL 2
#define _IO_FLAGS2_FORTIFY 4
#define _IO_FLAGS2_CLOEXEC 64
#define _IO_FLAGS2_NEED_LOCK 128
-/* These are "formatting flags" matching the iostream fmtflags enum values. */
-#define _IO_SKIPWS 01
-#define _IO_LEFT 02
-#define _IO_RIGHT 04
-#define _IO_INTERNAL 010
-#define _IO_DEC 020
-#define _IO_OCT 040
-#define _IO_HEX 0100
-#define _IO_SHOWBASE 0200
-#define _IO_SHOWPOINT 0400
-#define _IO_UPPERCASE 01000
-#define _IO_SHOWPOS 02000
-#define _IO_SCIENTIFIC 04000
-#define _IO_FIXED 010000
-#define _IO_UNITBUF 020000
-#define _IO_STDIO 040000
-#define _IO_DONT_CLOSE 0100000
-#define _IO_BOOLALPHA 0200000
-
struct _IO_jump_t;
/* A streammarker remembers a position in a buffer. */
-
struct _IO_marker {
struct _IO_marker *_next;
FILE *_sbuf;
#else
/* This is part of the kludge for binary compatibility with old stdio. */
# define COERCE_FILE(FILE) \
- (((FILE)->_IO_file_flags & _IO_MAGIC_MASK) == _OLD_MAGIC_MASK \
+ (((FILE)->_flags & _IO_MAGIC_MASK) == _OLD_MAGIC_MASK \
&& (FILE) = *(FILE**)&((int*)fp)[1])
#endif
# define CHECK_FILE(FILE, RET) \
if ((FILE) == NULL) { MAYBE_SET_EINVAL; return RET; } \
else { COERCE_FILE(FILE); \
- if (((FILE)->_IO_file_flags & _IO_MAGIC_MASK) != _IO_MAGIC) \
+ if (((FILE)->_flags & _IO_MAGIC_MASK) != _IO_MAGIC) \
{ MAYBE_SET_EINVAL; return RET; }}
#else
# define CHECK_FILE(FILE, RET) COERCE_FILE (FILE)
of our file descriptor. Hence we actually don't know the actual
position before we do the first fseek (and until a following fflush). */
fp->file._old_offset = _IO_pos_BAD;
- fp->file._IO_file_flags |= CLOSED_FILEBUF_FLAGS;
+ fp->file._flags |= CLOSED_FILEBUF_FLAGS;
_IO_link_in (fp);
fp->file._vtable_offset = ((int) sizeof (struct _IO_FILE)
return _IO_new_fclose (fp);
/* First unlink the stream. */
- if (fp->_IO_file_flags & _IO_IS_FILEBUF)
+ if (fp->_flags & _IO_IS_FILEBUF)
_IO_un_link ((struct _IO_FILE_plus *) fp);
_IO_acquire_lock (fp);
- if (fp->_IO_file_flags & _IO_IS_FILEBUF)
+ if (fp->_flags & _IO_IS_FILEBUF)
status = _IO_old_file_close_it (fp);
else
status = fp->_flags & _IO_ERR_SEEN ? -1 : 0;
_IO_free_backup_area (fp);
if (fp != _IO_stdin && fp != _IO_stdout && fp != _IO_stderr)
{
- fp->_IO_file_flags = 0;
+ fp->_flags = 0;
free(fp);
}
/* frozen: set when the program has requested that the array object not
be altered, reallocated, or freed. */
-#define _IO_STR_FROZEN(FP) ((FP)->_f._IO_file_flags & _IO_USER_BUF)
+#define _IO_STR_FROZEN(FP) ((FP)->_f._flags & _IO_USER_BUF)
typedef struct
{
_IO_str_init_readonly (_IO_strfile *sf, const char *ptr, int size)
{
_IO_str_init_static_internal (sf, (char *) ptr, size < 0 ? -1 : size, NULL);
- sf->_sbf._f._IO_file_flags |= _IO_NO_WRITES;
+ sf->_sbf._f._flags |= _IO_NO_WRITES;
}
int
return -1; \
} \
} while (0)
-#define UNBUFFERED_P(S) ((S)->_IO_file_flags & _IO_UNBUFFERED)
+#define UNBUFFERED_P(S) ((S)->_flags & _IO_UNBUFFERED)
#define done_add(val) \
do { \
_IO_setp (hp, buf, buf + sizeof buf);
hp->_mode = -1;
#endif
- hp->_IO_file_flags = _IO_MAGIC|_IO_NO_READS|_IO_USER_LOCK;
+ hp->_flags = _IO_MAGIC|_IO_NO_READS|_IO_USER_LOCK;
#if _IO_JUMPS_OFFSET
hp->_vtable_offset = 0;
#endif