summary refs log tree commit diff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--ChangeLog14
-rw-r--r--debug/fgets_chk.c9
-rw-r--r--debug/fgets_u_chk.c9
-rw-r--r--debug/fgetws_chk.c6
-rw-r--r--debug/fgetws_u_chk.c9
-rw-r--r--debug/gets_chk.c8
-rw-r--r--libio/bits/types/struct_FILE.h4
-rw-r--r--libio/fileops.c2
-rw-r--r--libio/iofclose.c6
-rw-r--r--libio/iofgets.c9
-rw-r--r--libio/iofgets_u.c9
-rw-r--r--libio/iofgetws.c6
-rw-r--r--libio/iofgetws_u.c9
-rw-r--r--libio/iogets.c8
-rw-r--r--libio/iosetvbuf.c12
-rw-r--r--libio/libio.h81
-rw-r--r--libio/libioP.h4
-rw-r--r--libio/oldfileops.c2
-rw-r--r--libio/oldiofclose.c6
-rw-r--r--libio/strfile.h2
-rw-r--r--libio/strops.c2
-rw-r--r--stdio-common/vfprintf.c4
22 files changed, 99 insertions, 122 deletions
diff --git a/ChangeLog b/ChangeLog
index f35b6e4a3b..26143536b1 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,19 @@
 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)
diff --git a/debug/fgets_chk.c b/debug/fgets_chk.c
index f223653370..f3548c7d61 100644
--- a/debug/fgets_chk.c
+++ b/debug/fgets_chk.c
@@ -40,13 +40,12 @@ __fgets_chk (char *buf, size_t size, int n, FILE *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. */
-  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 ();
@@ -55,7 +54,7 @@ __fgets_chk (char *buf, size_t size, int n, FILE *fp)
       buf[count] = '\0';
       result = buf;
     }
-  fp->_IO_file_flags |= old_error;
+  fp->_flags |= old_error;
   _IO_release_lock (fp);
   return result;
 }
diff --git a/debug/fgets_u_chk.c b/debug/fgets_u_chk.c
index 317ae5649d..924634c17b 100644
--- a/debug/fgets_u_chk.c
+++ b/debug/fgets_u_chk.c
@@ -39,13 +39,12 @@ __fgets_unlocked_chk (char *buf, size_t size, int n, FILE *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. */
-  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 ();
@@ -54,6 +53,6 @@ __fgets_unlocked_chk (char *buf, size_t size, int n, FILE *fp)
       buf[count] = '\0';
       result = buf;
     }
-  fp->_IO_file_flags |= old_error;
+  fp->_flags |= old_error;
   return result;
 }
diff --git a/debug/fgetws_chk.c b/debug/fgetws_chk.c
index 8ea6635b30..2380059f0f 100644
--- a/debug/fgetws_chk.c
+++ b/debug/fgetws_chk.c
@@ -32,8 +32,8 @@ __fgetws_chk (wchar_t *buf, size_t size, int n, FILE *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_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. */
@@ -46,7 +46,7 @@ __fgetws_chk (wchar_t *buf, size_t size, int n, FILE *fp)
       buf[count] = '\0';
       result = buf;
     }
-  fp->_IO_file_flags |= old_error;
+  fp->_flags |= old_error;
   _IO_release_lock (fp);
   return result;
 }
diff --git a/debug/fgetws_u_chk.c b/debug/fgetws_u_chk.c
index 42dad6bc8b..8147eb1e36 100644
--- a/debug/fgetws_u_chk.c
+++ b/debug/fgetws_u_chk.c
@@ -40,13 +40,12 @@ __fgetws_unlocked_chk (wchar_t *buf, size_t size, int n, FILE *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_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 ();
@@ -55,6 +54,6 @@ __fgetws_unlocked_chk (wchar_t *buf, size_t size, int n, FILE *fp)
       buf[count] = '\0';
       result = buf;
     }
-  fp->_IO_file_flags |= old_error;
+  fp->_flags |= old_error;
   return result;
 }
diff --git a/debug/gets_chk.c b/debug/gets_chk.c
index df3f947e70..2b1416b295 100644
--- a/debug/gets_chk.c
+++ b/debug/gets_chk.c
@@ -51,17 +51,17 @@ __gets_chk (char *buf, size_t size)
       /* 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 ();
diff --git a/libio/bits/types/struct_FILE.h b/libio/bits/types/struct_FILE.h
index a120c76268..359f949453 100644
--- a/libio/bits/types/struct_FILE.h
+++ b/libio/bits/types/struct_FILE.h
@@ -108,10 +108,10 @@ struct _IO_FILE_complete
    ? __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
diff --git a/libio/fileops.c b/libio/fileops.c
index 4b8e443bc2..ec1e2b5904 100644
--- a/libio/fileops.c
+++ b/libio/fileops.c
@@ -109,7 +109,7 @@ _IO_new_file_init_internal (struct _IO_FILE_plus *fp)
      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;
diff --git a/libio/iofclose.c b/libio/iofclose.c
index c7c44ed9b4..7a8b89f9f5 100644
--- a/libio/iofclose.c
+++ b/libio/iofclose.c
@@ -45,11 +45,11 @@ _IO_new_fclose (FILE *fp)
 #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;
@@ -73,7 +73,7 @@ _IO_new_fclose (FILE *fp)
     }
   if (fp != _IO_stdin && fp != _IO_stdout && fp != _IO_stderr)
     {
-      fp->_IO_file_flags = 0;
+      fp->_flags = 0;
       free(fp);
     }
 
diff --git a/libio/iofgets.c b/libio/iofgets.c
index b15b59d3bf..68177dbe22 100644
--- a/libio/iofgets.c
+++ b/libio/iofgets.c
@@ -48,20 +48,19 @@ _IO_fgets (char *buf, int n, FILE *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;
 }
diff --git a/libio/iofgets_u.c b/libio/iofgets_u.c
index 9091644685..9d33a37621 100644
--- a/libio/iofgets_u.c
+++ b/libio/iofgets_u.c
@@ -47,20 +47,19 @@ __fgets_unlocked (char *buf, int n, FILE *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;
   return result;
 }
 libc_hidden_def (__fgets_unlocked)
diff --git a/libio/iofgetws.c b/libio/iofgetws.c
index 0e2d515df5..292a161757 100644
--- a/libio/iofgetws.c
+++ b/libio/iofgetws.c
@@ -48,8 +48,8 @@ fgetws (wchar_t *buf, int n, FILE *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_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. */
@@ -60,7 +60,7 @@ fgetws (wchar_t *buf, int n, FILE *fp)
       buf[count] = '\0';
       result = buf;
     }
-  fp->_IO_file_flags |= old_error;
+  fp->_flags |= old_error;
   _IO_release_lock (fp);
   return result;
 }
diff --git a/libio/iofgetws_u.c b/libio/iofgetws_u.c
index a930b47a6d..46431a278b 100644
--- a/libio/iofgetws_u.c
+++ b/libio/iofgetws_u.c
@@ -47,19 +47,18 @@ fgetws_unlocked (wchar_t *buf, int n, FILE *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_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;
 }
diff --git a/libio/iogets.c b/libio/iogets.c
index 19048f6d03..c2223e6ecc 100644
--- a/libio/iogets.c
+++ b/libio/iogets.c
@@ -48,17 +48,17 @@ _IO_gets (char *buf)
       /* 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;
diff --git a/libio/iosetvbuf.c b/libio/iosetvbuf.c
index b29a93be54..a35d866d82 100644
--- a/libio/iosetvbuf.c
+++ b/libio/iosetvbuf.c
@@ -39,7 +39,7 @@ _IO_setvbuf (FILE *fp, char *buf, int mode, size_t size)
   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)
@@ -62,15 +62,15 @@ _IO_setvbuf (FILE *fp, char *buf, int mode, size_t size)
 		  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;
@@ -78,8 +78,8 @@ _IO_setvbuf (FILE *fp, char *buf, int mode, size_t size)
 	}
       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;
diff --git a/libio/libio.h b/libio/libio.h
index a3c679ca66..df40bfd5ba 100644
--- a/libio/libio.h
+++ b/libio/libio.h
@@ -60,45 +60,34 @@ typedef union
 
 #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
@@ -108,30 +97,10 @@ typedef union
 #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;
diff --git a/libio/libioP.h b/libio/libioP.h
index 5064bdf69d..ee23296ddb 100644
--- a/libio/libioP.h
+++ b/libio/libioP.h
@@ -761,7 +761,7 @@ extern struct _IO_fake_stdiobuf _IO_stdin_buf, _IO_stdout_buf, _IO_stderr_buf;
 #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
 
@@ -775,7 +775,7 @@ extern struct _IO_fake_stdiobuf _IO_stdin_buf, _IO_stdout_buf, _IO_stderr_buf;
 # 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)
diff --git a/libio/oldfileops.c b/libio/oldfileops.c
index e824a64bba..7298bf5324 100644
--- a/libio/oldfileops.c
+++ b/libio/oldfileops.c
@@ -102,7 +102,7 @@ _IO_old_file_init_internal (struct _IO_FILE_plus *fp)
      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)
diff --git a/libio/oldiofclose.c b/libio/oldiofclose.c
index 432a7dd89a..f414502fe0 100644
--- a/libio/oldiofclose.c
+++ b/libio/oldiofclose.c
@@ -46,11 +46,11 @@ _IO_old_fclose (FILE *fp)
     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;
@@ -60,7 +60,7 @@ _IO_old_fclose (FILE *fp)
     _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);
     }
 
diff --git a/libio/strfile.h b/libio/strfile.h
index b96fd0fb0a..46ac81809a 100644
--- a/libio/strfile.h
+++ b/libio/strfile.h
@@ -59,7 +59,7 @@ typedef struct _IO_strfile_
 
 /* 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
 {
diff --git a/libio/strops.c b/libio/strops.c
index adfa80749c..eddd722c09 100644
--- a/libio/strops.c
+++ b/libio/strops.c
@@ -74,7 +74,7 @@ void
 _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
diff --git a/stdio-common/vfprintf.c b/stdio-common/vfprintf.c
index 27d3a2c1bf..8f0a6f8cf2 100644
--- a/stdio-common/vfprintf.c
+++ b/stdio-common/vfprintf.c
@@ -62,7 +62,7 @@
 	  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 {									      \
@@ -2307,7 +2307,7 @@ buffered_vfprintf (FILE *s, const CHAR_T *format, va_list args)
   _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
generated by cgit-pink 1.4.1 (git 2.36.1) at 2024-11-13 12:59:16 +0000