libio/libio.h

   1 /* Copyright (C) 1991-1995,1997-2007,2009,2011,2012
   2    Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Written by Per Bothner <bothner@cygnus.com>.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, write to the Free
  18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.
  20
  21    As a special exception, if you link the code in this file with
  22    files compiled with a GNU compiler to produce an executable,
  23    that does not cause the resulting executable to be covered by
  24    the GNU Lesser General Public License.  This exception does not
  25    however invalidate any other reasons why the executable file
  26    might be covered by the GNU Lesser General Public License.
  27    This exception applies to code released by its copyright holders
  28    in files containing the exception.  */
  29
  30 #ifndef _IO_STDIO_H
  31 #define _IO_STDIO_H
  32
  33 #include <_G_config.h>
  34 /* ALL of these should be defined in _G_config.h */
  35 #define _IO_pos_t _G_fpos_t /* obsolete */
  36 #define _IO_fpos_t _G_fpos_t
  37 #define _IO_fpos64_t _G_fpos64_t
  38 #define _IO_size_t _G_size_t
  39 #define _IO_ssize_t _G_ssize_t
  40 #define _IO_off_t _G_off_t
  41 #define _IO_off64_t _G_off64_t
  42 #define _IO_pid_t _G_pid_t
  43 #define _IO_uid_t _G_uid_t
  44 #define _IO_iconv_t _G_iconv_t
  45 #define _IO_HAVE_SYS_WAIT _G_HAVE_SYS_WAIT
  46 #define _IO_HAVE_ST_BLKSIZE _G_HAVE_ST_BLKSIZE
  47 #define _IO_BUFSIZ _G_BUFSIZ
  48 #define _IO_va_list _G_va_list
  49 #define _IO_wint_t _G_wint_t
  50
  51 #ifdef _G_NEED_STDARG_H
  52 /* This define avoids name pollution if we're using GNU stdarg.h */
  53 # define __need___va_list
  54 # include <stdarg.h>
  55 # ifdef __GNUC_VA_LIST
  56 #  undef _IO_va_list
  57 #  define _IO_va_list __gnuc_va_list
  58 # endif /* __GNUC_VA_LIST */
  59 #endif
  60
  61 #ifndef __P
  62 # if _G_HAVE_SYS_CDEFS
  63 #  include <sys/cdefs.h>
  64 # else
  65 #  ifdef __STDC__
  66 #   define __P(p) p
  67 #   define __PMT(p) p
  68 #  else
  69 #   define __P(p) ()
  70 #   define __PMT(p) ()
  71 #  endif
  72 # endif
  73 #endif /*!__P*/
  74
  75 /* For backward compatibility */
  76 #ifndef _PARAMS
  77 # define _PARAMS(protos) __P(protos)
  78 #endif /*!_PARAMS*/
  79
  80 #ifndef __STDC__
  81 # ifndef const
  82 #  define const
  83 # endif
  84 #endif
  85 #define _IO_UNIFIED_JUMPTABLES 1
  86 #ifndef _G_HAVE_PRINTF_FP
  87 # define _IO_USE_DTOA 1
  88 #endif
  89
  90 #ifndef EOF
  91 # define EOF (-1)
  92 #endif
  93 #ifndef NULL
  94 # if defined __GNUG__ && \
  95     (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 8))
  96 #  define NULL (__null)
  97 # else
  98 #  if !defined(__cplusplus)
  99 #   define NULL ((void*)0)
 100 #  else
 101 #   define NULL (0)
 102 #  endif
 103 # endif
 104 #endif
 105
 106 #define _IOS_INPUT      1
 107 #define _IOS_OUTPUT     2
 108 #define _IOS_ATEND      4
 109 #define _IOS_APPEND     8
 110 #define _IOS_TRUNC      16
 111 #define _IOS_NOCREATE   32
 112 #define _IOS_NOREPLACE  64
 113 #define _IOS_BIN        128
 114
 115 /* Magic numbers and bits for the _flags field.
 116    The magic numbers use the high-order bits of _flags;
 117    the remaining bits are available for variable flags.
 118    Note: The magic numbers must all be negative if stdio
 119    emulation is desired. */
 120
 121 #define _IO_MAGIC 0xFBAD0000 /* Magic number */
 122 #define _OLD_STDIO_MAGIC 0xFABC0000 /* Emulate old stdio. */
 123 #define _IO_MAGIC_MASK 0xFFFF0000
 124 #define _IO_USER_BUF 1 /* User owns buffer; don't delete it on close. */
 125 #define _IO_UNBUFFERED 2
 126 #define _IO_NO_READS 4 /* Reading not allowed */
 127 #define _IO_NO_WRITES 8 /* Writing not allowd */
 128 #define _IO_EOF_SEEN 0x10
 129 #define _IO_ERR_SEEN 0x20
 130 #define _IO_DELETE_DONT_CLOSE 0x40 /* Don't call close(_fileno) on cleanup. */
 131 #define _IO_LINKED 0x80 /* Set if linked (using _chain) to streambuf::_list_all.*/
 132 #define _IO_IN_BACKUP 0x100
 133 #define _IO_LINE_BUF 0x200
 134 #define _IO_TIED_PUT_GET 0x400 /* Set if put and get pointer logicly tied. */
 135 #define _IO_CURRENTLY_PUTTING 0x800
 136 #define _IO_IS_APPENDING 0x1000
 137 #define _IO_IS_FILEBUF 0x2000
 138 #define _IO_BAD_SEEN 0x4000
 139 #define _IO_USER_LOCK 0x8000
 140
 141 #define _IO_FLAGS2_MMAP 1
 142 #define _IO_FLAGS2_NOTCANCEL 2
 143 #ifdef _LIBC
 144 # define _IO_FLAGS2_FORTIFY 4
 145 #endif
 146 #define _IO_FLAGS2_USER_WBUF 8
 147 #ifdef _LIBC
 148 # define _IO_FLAGS2_SCANF_STD 16
 149 # define _IO_FLAGS2_NOCLOSE 32
 150 # define _IO_FLAGS2_CLOEXEC 64
 151 #endif
 152
 153 /* These are "formatting flags" matching the iostream fmtflags enum values. */
 154 #define _IO_SKIPWS 01
 155 #define _IO_LEFT 02
 156 #define _IO_RIGHT 04
 157 #define _IO_INTERNAL 010
 158 #define _IO_DEC 020
 159 #define _IO_OCT 040
 160 #define _IO_HEX 0100
 161 #define _IO_SHOWBASE 0200
 162 #define _IO_SHOWPOINT 0400
 163 #define _IO_UPPERCASE 01000
 164 #define _IO_SHOWPOS 02000
 165 #define _IO_SCIENTIFIC 04000
 166 #define _IO_FIXED 010000
 167 #define _IO_UNITBUF 020000
 168 #define _IO_STDIO 040000
 169 #define _IO_DONT_CLOSE 0100000
 170 #define _IO_BOOLALPHA 0200000
 171
 172
 173 struct _IO_jump_t;  struct _IO_FILE;
 174
 175 /* Handle lock.  */
 176 #ifdef _IO_MTSAFE_IO
 177 # if defined __GLIBC__ && __GLIBC__ >= 2
 178 #  include <bits/stdio-lock.h>
 179 # else
 180 /*# include <comthread.h>*/
 181 # endif
 182 #else
 183 typedef void _IO_lock_t;
 184 #endif
 185
 186
 187 /* A streammarker remembers a position in a buffer. */
 188
 189 struct _IO_marker {
 190   struct _IO_marker *_next;
 191   struct _IO_FILE *_sbuf;
 192   /* If _pos >= 0
 193  it points to _buf->Gbase()+_pos. FIXME comment */
 194   /* if _pos < 0, it points to _buf->eBptr()+_pos. FIXME comment */
 195   int _pos;
 196 #if 0
 197     void set_streampos(streampos sp) { _spos = sp; }
 198     void set_offset(int offset) { _pos = offset; _spos = (streampos)(-2); }
 199   public:
 200     streammarker(streambuf *sb);
 201     ~streammarker();
 202     int saving() { return  _spos == -2; }
 203     int delta(streammarker&);
 204     int delta();
 205 #endif
 206 };
 207
 208 /* This is the structure from the libstdc++ codecvt class.  */
 209 enum __codecvt_result
 210 {
 211   __codecvt_ok,
 212   __codecvt_partial,
 213   __codecvt_error,
 214   __codecvt_noconv
 215 };
 216
 217 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
 218 /* The order of the elements in the following struct must match the order
 219    of the virtual functions in the libstdc++ codecvt class.  */
 220 struct _IO_codecvt
 221 {
 222   void (*__codecvt_destr) (struct _IO_codecvt *);
 223   enum __codecvt_result (*__codecvt_do_out) (struct _IO_codecvt *,
 224                                              __mbstate_t *,
 225                                              const wchar_t *,
 226                                              const wchar_t *,
 227                                              const wchar_t **, char *,
 228                                              char *, char **);
 229   enum __codecvt_result (*__codecvt_do_unshift) (struct _IO_codecvt *,
 230                                                  __mbstate_t *, char *,
 231                                                  char *, char **);
 232   enum __codecvt_result (*__codecvt_do_in) (struct _IO_codecvt *,
 233                                             __mbstate_t *,
 234                                             const char *, const char *,
 235                                             const char **, wchar_t *,
 236                                             wchar_t *, wchar_t **);
 237   int (*__codecvt_do_encoding) (struct _IO_codecvt *);
 238   int (*__codecvt_do_always_noconv) (struct _IO_codecvt *);
 239   int (*__codecvt_do_length) (struct _IO_codecvt *, __mbstate_t *,
 240                               const char *, const char *, _IO_size_t);
 241   int (*__codecvt_do_max_length) (struct _IO_codecvt *);
 242
 243   _IO_iconv_t __cd_in;
 244   _IO_iconv_t __cd_out;
 245 };
 246
 247 /* Extra data for wide character streams.  */
 248 struct _IO_wide_data
 249 {
 250   wchar_t *_IO_read_ptr;        /* Current read pointer */
 251   wchar_t *_IO_read_end;        /* End of get area. */
 252   wchar_t *_IO_read_base;       /* Start of putback+get area. */
 253   wchar_t *_IO_write_base;      /* Start of put area. */
 254   wchar_t *_IO_write_ptr;       /* Current put pointer. */
 255   wchar_t *_IO_write_end;       /* End of put area. */
 256   wchar_t *_IO_buf_base;        /* Start of reserve area. */
 257   wchar_t *_IO_buf_end;         /* End of reserve area. */
 258   /* The following fields are used to support backing up and undo. */
 259   wchar_t *_IO_save_base;       /* Pointer to start of non-current get area. */
 260   wchar_t *_IO_backup_base;     /* Pointer to first valid character of
 261                                    backup area */
 262   wchar_t *_IO_save_end;        /* Pointer to end of non-current get area. */
 263
 264   __mbstate_t _IO_state;
 265   __mbstate_t _IO_last_state;
 266   struct _IO_codecvt _codecvt;
 267
 268   wchar_t _shortbuf[1];
 269
 270   const struct _IO_jump_t *_wide_vtable;
 271 };
 272 #endif
 273
 274 struct _IO_FILE {
 275   int _flags;           /* High-order word is _IO_MAGIC; rest is flags. */
 276 #define _IO_file_flags _flags
 277
 278   /* The following pointers correspond to the C++ streambuf protocol. */
 279   /* Note:  Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
 280   char* _IO_read_ptr;   /* Current read pointer */
 281   char* _IO_read_end;   /* End of get area. */
 282   char* _IO_read_base;  /* Start of putback+get area. */
 283   char* _IO_write_base; /* Start of put area. */
 284   char* _IO_write_ptr;  /* Current put pointer. */
 285   char* _IO_write_end;  /* End of put area. */
 286   char* _IO_buf_base;   /* Start of reserve area. */
 287   char* _IO_buf_end;    /* End of reserve area. */
 288   /* The following fields are used to support backing up and undo. */
 289   char *_IO_save_base; /* Pointer to start of non-current get area. */
 290   char *_IO_backup_base;  /* Pointer to first valid character of backup area */
 291   char *_IO_save_end; /* Pointer to end of non-current get area. */
 292
 293   struct _IO_marker *_markers;
 294
 295   struct _IO_FILE *_chain;
 296
 297   int _fileno;
 298 #if 0
 299   int _blksize;
 300 #else
 301   int _flags2;
 302 #endif
 303   _IO_off_t _old_offset; /* This used to be _offset but it's too small.  */
 304
 305 #define __HAVE_COLUMN /* temporary */
 306   /* 1+column number of pbase(); 0 is unknown. */
 307   unsigned short _cur_column;
 308   signed char _vtable_offset;
 309   char _shortbuf[1];
 310
 311   /*  char* _save_gptr;  char* _save_egptr; */
 312
 313   _IO_lock_t *_lock;
 314 #ifdef _IO_USE_OLD_IO_FILE
 315 };
 316
 317 struct _IO_FILE_complete
 318 {
 319   struct _IO_FILE _file;
 320 #endif
 321 #if defined _G_IO_IO_FILE_VERSION && _G_IO_IO_FILE_VERSION == 0x20001
 322   _IO_off64_t _offset;
 323 # if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
 324   /* Wide character stream stuff.  */
 325   struct _IO_codecvt *_codecvt;
 326   struct _IO_wide_data *_wide_data;
 327   struct _IO_FILE *_freeres_list;
 328   void *_freeres_buf;
 329   size_t _freeres_size;
 330 # else
 331   void *__pad1;
 332   void *__pad2;
 333   void *__pad3;
 334   void *__pad4;
 335   size_t __pad5;
 336 # endif
 337   int _mode;
 338   /* Make sure we don't get into trouble again.  */
 339   char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
 340 #endif
 341 };
 342
 343 #ifndef __cplusplus
 344 typedef struct _IO_FILE _IO_FILE;
 345 #endif
 346
 347 struct _IO_FILE_plus;
 348
 349 extern struct _IO_FILE_plus _IO_2_1_stdin_;
 350 extern struct _IO_FILE_plus _IO_2_1_stdout_;
 351 extern struct _IO_FILE_plus _IO_2_1_stderr_;
 352 #ifndef _LIBC
 353 #define _IO_stdin ((_IO_FILE*)(&_IO_2_1_stdin_))
 354 #define _IO_stdout ((_IO_FILE*)(&_IO_2_1_stdout_))
 355 #define _IO_stderr ((_IO_FILE*)(&_IO_2_1_stderr_))
 356 #else
 357 extern _IO_FILE *_IO_stdin attribute_hidden;
 358 extern _IO_FILE *_IO_stdout attribute_hidden;
 359 extern _IO_FILE *_IO_stderr attribute_hidden;
 360 #endif
 361
 362
 363 /* Functions to do I/O and file management for a stream.  */
 364
 365 /* Read NBYTES bytes from COOKIE into a buffer pointed to by BUF.
 366    Return number of bytes read.  */
 367 typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
 368
 369 /* Write N bytes pointed to by BUF to COOKIE.  Write all N bytes
 370    unless there is an error.  Return number of bytes written, or -1 if
 371    there is an error without writing anything.  If the file has been
 372    opened for append (__mode.__append set), then set the file pointer
 373    to the end of the file and then do the write; if not, just write at
 374    the current file pointer.  */
 375 typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf,
 376                                  size_t __n);
 377
 378 /* Move COOKIE's file position to *POS bytes from the
 379    beginning of the file (if W is SEEK_SET),
 380    the current position (if W is SEEK_CUR),
 381    or the end of the file (if W is SEEK_END).
 382    Set *POS to the new file position.
 383    Returns zero if successful, nonzero if not.  */
 384 typedef int __io_seek_fn (void *__cookie, _IO_off64_t *__pos, int __w);
 385
 386 /* Close COOKIE.  */
 387 typedef int __io_close_fn (void *__cookie);
 388
 389
 390 #ifdef _GNU_SOURCE
 391 /* User-visible names for the above.  */
 392 typedef __io_read_fn cookie_read_function_t;
 393 typedef __io_write_fn cookie_write_function_t;
 394 typedef __io_seek_fn cookie_seek_function_t;
 395 typedef __io_close_fn cookie_close_function_t;
 396
 397 /* The structure with the cookie function pointers.  */
 398 typedef struct
 399 {
 400   __io_read_fn *read;           /* Read bytes.  */
 401   __io_write_fn *write;         /* Write bytes.  */
 402   __io_seek_fn *seek;           /* Seek/tell file position.  */
 403   __io_close_fn *close;         /* Close file.  */
 404 } _IO_cookie_io_functions_t;
 405 typedef _IO_cookie_io_functions_t cookie_io_functions_t;
 406
 407 struct _IO_cookie_file;
 408
 409 /* Initialize one of those.  */
 410 extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
 411                              void *__cookie, _IO_cookie_io_functions_t __fns);
 412 #endif
 413
 414
 415 #ifdef __cplusplus
 416 extern "C" {
 417 #endif
 418
 419 extern int __underflow (_IO_FILE *);
 420 extern int __uflow (_IO_FILE *);
 421 extern int __overflow (_IO_FILE *, int);
 422 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
 423 extern _IO_wint_t __wunderflow (_IO_FILE *);
 424 extern _IO_wint_t __wuflow (_IO_FILE *);
 425 extern _IO_wint_t __woverflow (_IO_FILE *, _IO_wint_t);
 426 #endif
 427
 428 #if  __GNUC__ >= 3
 429 # define _IO_BE(expr, res) __builtin_expect ((expr), res)
 430 #else
 431 # define _IO_BE(expr, res) (expr)
 432 #endif
 433
 434 #define _IO_getc_unlocked(_fp) \
 435        (_IO_BE ((_fp)->_IO_read_ptr >= (_fp)->_IO_read_end, 0) \
 436         ? __uflow (_fp) : *(unsigned char *) (_fp)->_IO_read_ptr++)
 437 #define _IO_peekc_unlocked(_fp) \
 438        (_IO_BE ((_fp)->_IO_read_ptr >= (_fp)->_IO_read_end, 0) \
 439           && __underflow (_fp) == EOF ? EOF \
 440         : *(unsigned char *) (_fp)->_IO_read_ptr)
 441 #define _IO_putc_unlocked(_ch, _fp) \
 442    (_IO_BE ((_fp)->_IO_write_ptr >= (_fp)->_IO_write_end, 0) \
 443     ? __overflow (_fp, (unsigned char) (_ch)) \
 444     : (unsigned char) (*(_fp)->_IO_write_ptr++ = (_ch)))
 445
 446 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
 447 # define _IO_getwc_unlocked(_fp) \
 448   (_IO_BE ((_fp)->_wide_data == NULL                                    \
 449            || ((_fp)->_wide_data->_IO_read_ptr                          \
 450                >= (_fp)->_wide_data->_IO_read_end), 0)                  \
 451    ? __wuflow (_fp) : (_IO_wint_t) *(_fp)->_wide_data->_IO_read_ptr++)
 452 # define _IO_putwc_unlocked(_wch, _fp) \
 453   (_IO_BE ((_fp)->_wide_data == NULL                                    \
 454            || ((_fp)->_wide_data->_IO_write_ptr                         \
 455                >= (_fp)->_wide_data->_IO_write_end), 0)                 \
 456    ? __woverflow (_fp, _wch)                                            \
 457    : (_IO_wint_t) (*(_fp)->_wide_data->_IO_write_ptr++ = (_wch)))
 458 #endif
 459
 460 #define _IO_feof_unlocked(__fp) (((__fp)->_flags & _IO_EOF_SEEN) != 0)
 461 #define _IO_ferror_unlocked(__fp) (((__fp)->_flags & _IO_ERR_SEEN) != 0)
 462
 463 extern int _IO_getc (_IO_FILE *__fp);
 464 extern int _IO_putc (int __c, _IO_FILE *__fp);
 465 extern int _IO_feof (_IO_FILE *__fp) __THROW;
 466 extern int _IO_ferror (_IO_FILE *__fp) __THROW;
 467
 468 extern int _IO_peekc_locked (_IO_FILE *__fp);
 469
 470 /* This one is for Emacs. */
 471 #define _IO_PENDING_OUTPUT_COUNT(_fp)   \
 472         ((_fp)->_IO_write_ptr - (_fp)->_IO_write_base)
 473
 474 extern void _IO_flockfile (_IO_FILE *) __THROW;
 475 extern void _IO_funlockfile (_IO_FILE *) __THROW;
 476 extern int _IO_ftrylockfile (_IO_FILE *) __THROW;
 477
 478 #ifdef _IO_MTSAFE_IO
 479 # define _IO_peekc(_fp) _IO_peekc_locked (_fp)
 480 # define _IO_flockfile(_fp) \
 481   if (((_fp)->_flags & _IO_USER_LOCK) == 0) _IO_flockfile (_fp)
 482 # define _IO_funlockfile(_fp) \
 483   if (((_fp)->_flags & _IO_USER_LOCK) == 0) _IO_funlockfile (_fp)
 484 #else
 485 # define _IO_peekc(_fp) _IO_peekc_unlocked (_fp)
 486 # define _IO_flockfile(_fp) /**/
 487 # define _IO_funlockfile(_fp) /**/
 488 # define _IO_ftrylockfile(_fp) /**/
 489 # define _IO_cleanup_region_start(_fct, _fp) /**/
 490 # define _IO_cleanup_region_end(_Doit) /**/
 491 #endif /* !_IO_MTSAFE_IO */
 492
 493 extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
 494                         _IO_va_list, int *__restrict);
 495 extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
 496                          _IO_va_list);
 497 extern _IO_ssize_t _IO_padn (_IO_FILE *, int, _IO_ssize_t);
 498 extern _IO_size_t _IO_sgetn (_IO_FILE *, void *, _IO_size_t);
 499
 500 extern _IO_off64_t _IO_seekoff (_IO_FILE *, _IO_off64_t, int, int);
 501 extern _IO_off64_t _IO_seekpos (_IO_FILE *, _IO_off64_t, int);
 502
 503 extern void _IO_free_backup_area (_IO_FILE *) __THROW;
 504
 505 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
 506 extern _IO_wint_t _IO_getwc (_IO_FILE *__fp);
 507 extern _IO_wint_t _IO_putwc (wchar_t __wc, _IO_FILE *__fp);
 508 extern int _IO_fwide (_IO_FILE *__fp, int __mode) __THROW;
 509 # if __GNUC__ >= 2
 510 /* While compiling glibc we have to handle compatibility with very old
 511    versions.  */
 512 #  if defined _LIBC && defined SHARED
 513 #   include <shlib-compat.h>
 514 #   if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_1)
 515 #    define _IO_fwide_maybe_incompatible \
 516   (__builtin_expect (&_IO_stdin_used == NULL, 0))
 517 extern const int _IO_stdin_used;
 518 weak_extern (_IO_stdin_used);
 519 #   endif
 520 #  endif
 521 #  ifndef _IO_fwide_maybe_incompatible
 522 #   define _IO_fwide_maybe_incompatible (0)
 523 #  endif
 524 /* A special optimized version of the function above.  It optimizes the
 525    case of initializing an unoriented byte stream.  */
 526 #  define _IO_fwide(__fp, __mode) \
 527   ({ int __result = (__mode);                                                 \
 528      if (__result < 0 && ! _IO_fwide_maybe_incompatible)                      \
 529        {                                                                      \
 530          if ((__fp)->_mode == 0)                                              \
 531            /* We know that all we have to do is to set the flag.  */          \
 532            (__fp)->_mode = -1;                                                \
 533          __result = (__fp)->_mode;                                            \
 534        }                                                                      \
 535      else if (__builtin_constant_p (__mode) && (__mode) == 0)                 \
 536        __result = _IO_fwide_maybe_incompatible ? -1 : (__fp)->_mode;          \
 537      else                                                                     \
 538        __result = _IO_fwide (__fp, __result);                                 \
 539      __result; })
 540 # endif
 541
 542 extern int _IO_vfwscanf (_IO_FILE * __restrict, const wchar_t * __restrict,
 543                          _IO_va_list, int *__restrict);
 544 extern int _IO_vfwprintf (_IO_FILE *__restrict, const wchar_t *__restrict,
 545                           _IO_va_list);
 546 extern _IO_ssize_t _IO_wpadn (_IO_FILE *, wint_t, _IO_ssize_t);
 547 extern void _IO_free_wbackup_area (_IO_FILE *) __THROW;
 548 #endif
 549
 550 #ifdef __LDBL_COMPAT
 551 # include <bits/libio-ldbl.h>
 552 #endif
 553
 554 #ifdef __cplusplus
 555 }
 556 #endif
 557
 558 #endif /* _IO_STDIO_H */