lh | 9ed821d | 2023-04-07 01:36:19 -0700 | [diff] [blame] | 1 | /* Copyright (C) 1993-2015 Free Software Foundation, Inc. |
| 2 | This file is part of the GNU C Library. |
| 3 | |
| 4 | The GNU C Library is free software; you can redistribute it and/or |
| 5 | modify it under the terms of the GNU Lesser General Public |
| 6 | License as published by the Free Software Foundation; either |
| 7 | version 2.1 of the License, or (at your option) any later version. |
| 8 | |
| 9 | The GNU C Library is distributed in the hope that it will be useful, |
| 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 12 | Lesser General Public License for more details. |
| 13 | |
| 14 | You should have received a copy of the GNU Lesser General Public |
| 15 | License along with the GNU C Library; if not, see |
| 16 | <http://www.gnu.org/licenses/>. |
| 17 | |
| 18 | As a special exception, if you link the code in this file with |
| 19 | files compiled with a GNU compiler to produce an executable, |
| 20 | that does not cause the resulting executable to be covered by |
| 21 | the GNU Lesser General Public License. This exception does not |
| 22 | however invalidate any other reasons why the executable file |
| 23 | might be covered by the GNU Lesser General Public License. |
| 24 | This exception applies to code released by its copyright holders |
| 25 | in files containing the exception. */ |
| 26 | |
| 27 | /* NOTE: libio is now exclusively used only by glibc since libstdc++ has its |
| 28 | own implementation. As a result, functions that were implemented for C++ |
| 29 | (like *sputn) may no longer have C++ semantics. This is of course only |
| 30 | relevant for internal callers of these functions since these functions are |
| 31 | not intended for external use otherwise. |
| 32 | |
| 33 | FIXME: All of the C++ cruft eventually needs to go away. */ |
| 34 | |
| 35 | #include <stddef.h> |
| 36 | |
| 37 | #include <errno.h> |
| 38 | #ifndef __set_errno |
| 39 | # define __set_errno(Val) errno = (Val) |
| 40 | #endif |
| 41 | #if defined __GLIBC__ && __GLIBC__ >= 2 |
| 42 | # include <bits/libc-lock.h> |
| 43 | #else |
| 44 | /*# include <comthread.h>*/ |
| 45 | #endif |
| 46 | |
| 47 | #include <math_ldbl_opt.h> |
| 48 | |
| 49 | #include "iolibio.h" |
| 50 | |
| 51 | /* Control of exported symbols. Used in glibc. By default we don't |
| 52 | do anything. */ |
| 53 | #ifndef libc_hidden_proto |
| 54 | # define libc_hidden_proto(name) |
| 55 | #endif |
| 56 | #ifndef libc_hidden_def |
| 57 | # define libc_hidden_def(name) |
| 58 | #endif |
| 59 | #ifndef libc_hidden_weak |
| 60 | # define libc_hidden_weak(name) |
| 61 | #endif |
| 62 | |
| 63 | #ifdef __cplusplus |
| 64 | extern "C" { |
| 65 | #endif |
| 66 | |
| 67 | #define _IO_seek_set 0 |
| 68 | #define _IO_seek_cur 1 |
| 69 | #define _IO_seek_end 2 |
| 70 | |
| 71 | /* THE JUMPTABLE FUNCTIONS. |
| 72 | |
| 73 | * The _IO_FILE type is used to implement the FILE type in GNU libc, |
| 74 | * as well as the streambuf class in GNU iostreams for C++. |
| 75 | * These are all the same, just used differently. |
| 76 | * An _IO_FILE (or FILE) object is allows followed by a pointer to |
| 77 | * a jump table (of pointers to functions). The pointer is accessed |
| 78 | * with the _IO_JUMPS macro. The jump table has an eccentric format, |
| 79 | * so as to be compatible with the layout of a C++ virtual function table. |
| 80 | * (as implemented by g++). When a pointer to a streambuf object is |
| 81 | * coerced to an (_IO_FILE*), then _IO_JUMPS on the result just |
| 82 | * happens to point to the virtual function table of the streambuf. |
| 83 | * Thus the _IO_JUMPS function table used for C stdio/libio does |
| 84 | * double duty as the virtual function table for C++ streambuf. |
| 85 | * |
| 86 | * The entries in the _IO_JUMPS function table (and hence also the |
| 87 | * virtual functions of a streambuf) are described below. |
| 88 | * The first parameter of each function entry is the _IO_FILE/streambuf |
| 89 | * object being acted on (i.e. the 'this' parameter). |
| 90 | */ |
| 91 | |
| 92 | #ifdef _LIBC |
| 93 | # include <shlib-compat.h> |
| 94 | # if !SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_1) |
| 95 | /* Setting this macro disables the use of the _vtable_offset |
| 96 | bias in _IO_JUMPS_FUNCS, below. That is only needed if we |
| 97 | want to support old binaries (see oldfileops.c). */ |
| 98 | # define _G_IO_NO_BACKWARD_COMPAT 1 |
| 99 | # endif |
| 100 | #endif |
| 101 | |
| 102 | #if (!defined _IO_USE_OLD_IO_FILE \ |
| 103 | && (!defined _G_IO_NO_BACKWARD_COMPAT || _G_IO_NO_BACKWARD_COMPAT == 0)) |
| 104 | # define _IO_JUMPS_OFFSET 1 |
| 105 | #else |
| 106 | # define _IO_JUMPS_OFFSET 0 |
| 107 | #endif |
| 108 | |
| 109 | /* Type of MEMBER in struct type TYPE. */ |
| 110 | #define _IO_MEMBER_TYPE(TYPE, MEMBER) __typeof__ (((TYPE){}).MEMBER) |
| 111 | |
| 112 | /* Essentially ((TYPE *) THIS)->MEMBER, but avoiding the aliasing |
| 113 | violation in case THIS has a different pointer type. */ |
| 114 | #define _IO_CAST_FIELD_ACCESS(THIS, TYPE, MEMBER) \ |
| 115 | (*(_IO_MEMBER_TYPE (TYPE, MEMBER) *)(((char *) (THIS)) \ |
| 116 | + offsetof(TYPE, MEMBER))) |
| 117 | |
| 118 | #define _IO_JUMPS(THIS) (THIS)->vtable |
| 119 | #define _IO_JUMPS_FILE_plus(THIS) \ |
| 120 | _IO_CAST_FIELD_ACCESS ((THIS), struct _IO_FILE_plus, vtable) |
| 121 | #define _IO_WIDE_JUMPS(THIS) \ |
| 122 | _IO_CAST_FIELD_ACCESS ((THIS), struct _IO_FILE, _wide_data)->_wide_vtable |
| 123 | #define _IO_CHECK_WIDE(THIS) \ |
| 124 | (_IO_CAST_FIELD_ACCESS ((THIS), struct _IO_FILE, _wide_data) != NULL) |
| 125 | |
| 126 | #if _IO_JUMPS_OFFSET |
| 127 | # define _IO_JUMPS_FUNC(THIS) \ |
| 128 | (*(struct _IO_jump_t **) ((void *) &_IO_JUMPS_FILE_plus (THIS) \ |
| 129 | + (THIS)->_vtable_offset)) |
| 130 | # define _IO_vtable_offset(THIS) (THIS)->_vtable_offset |
| 131 | #else |
| 132 | # define _IO_JUMPS_FUNC(THIS) _IO_JUMPS_FILE_plus (THIS) |
| 133 | # define _IO_vtable_offset(THIS) 0 |
| 134 | #endif |
| 135 | #define _IO_WIDE_JUMPS_FUNC(THIS) _IO_WIDE_JUMPS(THIS) |
| 136 | #define JUMP_FIELD(TYPE, NAME) TYPE NAME |
| 137 | #define JUMP0(FUNC, THIS) (_IO_JUMPS_FUNC(THIS)->FUNC) (THIS) |
| 138 | #define JUMP1(FUNC, THIS, X1) (_IO_JUMPS_FUNC(THIS)->FUNC) (THIS, X1) |
| 139 | #define JUMP2(FUNC, THIS, X1, X2) (_IO_JUMPS_FUNC(THIS)->FUNC) (THIS, X1, X2) |
| 140 | #define JUMP3(FUNC, THIS, X1,X2,X3) (_IO_JUMPS_FUNC(THIS)->FUNC) (THIS, X1,X2, X3) |
| 141 | #define JUMP_INIT(NAME, VALUE) VALUE |
| 142 | #define JUMP_INIT_DUMMY JUMP_INIT(dummy, 0), JUMP_INIT (dummy2, 0) |
| 143 | |
| 144 | #define WJUMP0(FUNC, THIS) (_IO_WIDE_JUMPS_FUNC(THIS)->FUNC) (THIS) |
| 145 | #define WJUMP1(FUNC, THIS, X1) (_IO_WIDE_JUMPS_FUNC(THIS)->FUNC) (THIS, X1) |
| 146 | #define WJUMP2(FUNC, THIS, X1, X2) (_IO_WIDE_JUMPS_FUNC(THIS)->FUNC) (THIS, X1, X2) |
| 147 | #define WJUMP3(FUNC, THIS, X1,X2,X3) (_IO_WIDE_JUMPS_FUNC(THIS)->FUNC) (THIS, X1,X2, X3) |
| 148 | |
| 149 | /* The 'finish' function does any final cleaning up of an _IO_FILE object. |
| 150 | It does not delete (free) it, but does everything else to finalize it. |
| 151 | It matches the streambuf::~streambuf virtual destructor. */ |
| 152 | typedef void (*_IO_finish_t) (_IO_FILE *, int); /* finalize */ |
| 153 | #define _IO_FINISH(FP) JUMP1 (__finish, FP, 0) |
| 154 | #define _IO_WFINISH(FP) WJUMP1 (__finish, FP, 0) |
| 155 | |
| 156 | /* The 'overflow' hook flushes the buffer. |
| 157 | The second argument is a character, or EOF. |
| 158 | It matches the streambuf::overflow virtual function. */ |
| 159 | typedef int (*_IO_overflow_t) (_IO_FILE *, int); |
| 160 | #define _IO_OVERFLOW(FP, CH) JUMP1 (__overflow, FP, CH) |
| 161 | #define _IO_WOVERFLOW(FP, CH) WJUMP1 (__overflow, FP, CH) |
| 162 | |
| 163 | /* The 'underflow' hook tries to fills the get buffer. |
| 164 | It returns the next character (as an unsigned char) or EOF. The next |
| 165 | character remains in the get buffer, and the get position is not changed. |
| 166 | It matches the streambuf::underflow virtual function. */ |
| 167 | typedef int (*_IO_underflow_t) (_IO_FILE *); |
| 168 | #define _IO_UNDERFLOW(FP) JUMP0 (__underflow, FP) |
| 169 | #define _IO_WUNDERFLOW(FP) WJUMP0 (__underflow, FP) |
| 170 | |
| 171 | /* The 'uflow' hook returns the next character in the input stream |
| 172 | (cast to unsigned char), and increments the read position; |
| 173 | EOF is returned on failure. |
| 174 | It matches the streambuf::uflow virtual function, which is not in the |
| 175 | cfront implementation, but was added to C++ by the ANSI/ISO committee. */ |
| 176 | #define _IO_UFLOW(FP) JUMP0 (__uflow, FP) |
| 177 | #define _IO_WUFLOW(FP) WJUMP0 (__uflow, FP) |
| 178 | |
| 179 | /* The 'pbackfail' hook handles backing up. |
| 180 | It matches the streambuf::pbackfail virtual function. */ |
| 181 | typedef int (*_IO_pbackfail_t) (_IO_FILE *, int); |
| 182 | #define _IO_PBACKFAIL(FP, CH) JUMP1 (__pbackfail, FP, CH) |
| 183 | #define _IO_WPBACKFAIL(FP, CH) WJUMP1 (__pbackfail, FP, CH) |
| 184 | |
| 185 | /* The 'xsputn' hook writes upto N characters from buffer DATA. |
| 186 | Returns EOF or the number of character actually written. |
| 187 | It matches the streambuf::xsputn virtual function. */ |
| 188 | typedef _IO_size_t (*_IO_xsputn_t) (_IO_FILE *FP, const void *DATA, |
| 189 | _IO_size_t N); |
| 190 | #define _IO_XSPUTN(FP, DATA, N) JUMP2 (__xsputn, FP, DATA, N) |
| 191 | #define _IO_WXSPUTN(FP, DATA, N) WJUMP2 (__xsputn, FP, DATA, N) |
| 192 | |
| 193 | /* The 'xsgetn' hook reads upto N characters into buffer DATA. |
| 194 | Returns the number of character actually read. |
| 195 | It matches the streambuf::xsgetn virtual function. */ |
| 196 | typedef _IO_size_t (*_IO_xsgetn_t) (_IO_FILE *FP, void *DATA, _IO_size_t N); |
| 197 | #define _IO_XSGETN(FP, DATA, N) JUMP2 (__xsgetn, FP, DATA, N) |
| 198 | #define _IO_WXSGETN(FP, DATA, N) WJUMP2 (__xsgetn, FP, DATA, N) |
| 199 | |
| 200 | /* The 'seekoff' hook moves the stream position to a new position |
| 201 | relative to the start of the file (if DIR==0), the current position |
| 202 | (MODE==1), or the end of the file (MODE==2). |
| 203 | It matches the streambuf::seekoff virtual function. |
| 204 | It is also used for the ANSI fseek function. */ |
| 205 | typedef _IO_off64_t (*_IO_seekoff_t) (_IO_FILE *FP, _IO_off64_t OFF, int DIR, |
| 206 | int MODE); |
| 207 | #define _IO_SEEKOFF(FP, OFF, DIR, MODE) JUMP3 (__seekoff, FP, OFF, DIR, MODE) |
| 208 | #define _IO_WSEEKOFF(FP, OFF, DIR, MODE) WJUMP3 (__seekoff, FP, OFF, DIR, MODE) |
| 209 | |
| 210 | /* The 'seekpos' hook also moves the stream position, |
| 211 | but to an absolute position given by a fpos64_t (seekpos). |
| 212 | It matches the streambuf::seekpos virtual function. |
| 213 | It is also used for the ANSI fgetpos and fsetpos functions. */ |
| 214 | /* The _IO_seek_cur and _IO_seek_end options are not allowed. */ |
| 215 | typedef _IO_off64_t (*_IO_seekpos_t) (_IO_FILE *, _IO_off64_t, int); |
| 216 | #define _IO_SEEKPOS(FP, POS, FLAGS) JUMP2 (__seekpos, FP, POS, FLAGS) |
| 217 | #define _IO_WSEEKPOS(FP, POS, FLAGS) WJUMP2 (__seekpos, FP, POS, FLAGS) |
| 218 | |
| 219 | /* The 'setbuf' hook gives a buffer to the file. |
| 220 | It matches the streambuf::setbuf virtual function. */ |
| 221 | typedef _IO_FILE* (*_IO_setbuf_t) (_IO_FILE *, char *, _IO_ssize_t); |
| 222 | #define _IO_SETBUF(FP, BUFFER, LENGTH) JUMP2 (__setbuf, FP, BUFFER, LENGTH) |
| 223 | #define _IO_WSETBUF(FP, BUFFER, LENGTH) WJUMP2 (__setbuf, FP, BUFFER, LENGTH) |
| 224 | |
| 225 | /* The 'sync' hook attempts to synchronize the internal data structures |
| 226 | of the file with the external state. |
| 227 | It matches the streambuf::sync virtual function. */ |
| 228 | typedef int (*_IO_sync_t) (_IO_FILE *); |
| 229 | #define _IO_SYNC(FP) JUMP0 (__sync, FP) |
| 230 | #define _IO_WSYNC(FP) WJUMP0 (__sync, FP) |
| 231 | |
| 232 | /* The 'doallocate' hook is used to tell the file to allocate a buffer. |
| 233 | It matches the streambuf::doallocate virtual function, which is not |
| 234 | in the ANSI/ISO C++ standard, but is part traditional implementations. */ |
| 235 | typedef int (*_IO_doallocate_t) (_IO_FILE *); |
| 236 | #define _IO_DOALLOCATE(FP) JUMP0 (__doallocate, FP) |
| 237 | #define _IO_WDOALLOCATE(FP) WJUMP0 (__doallocate, FP) |
| 238 | |
| 239 | /* The following four hooks (sysread, syswrite, sysclose, sysseek, and |
| 240 | sysstat) are low-level hooks specific to this implementation. |
| 241 | There is no correspondence in the ANSI/ISO C++ standard library. |
| 242 | The hooks basically correspond to the Unix system functions |
| 243 | (read, write, close, lseek, and stat) except that a _IO_FILE* |
| 244 | parameter is used instead of an integer file descriptor; the default |
| 245 | implementation used for normal files just calls those functions. |
| 246 | The advantage of overriding these functions instead of the higher-level |
| 247 | ones (underflow, overflow etc) is that you can leave all the buffering |
| 248 | higher-level functions. */ |
| 249 | |
| 250 | /* The 'sysread' hook is used to read data from the external file into |
| 251 | an existing buffer. It generalizes the Unix read(2) function. |
| 252 | It matches the streambuf::sys_read virtual function, which is |
| 253 | specific to this implementation. */ |
| 254 | typedef _IO_ssize_t (*_IO_read_t) (_IO_FILE *, void *, _IO_ssize_t); |
| 255 | #define _IO_SYSREAD(FP, DATA, LEN) JUMP2 (__read, FP, DATA, LEN) |
| 256 | #define _IO_WSYSREAD(FP, DATA, LEN) WJUMP2 (__read, FP, DATA, LEN) |
| 257 | |
| 258 | /* The 'syswrite' hook is used to write data from an existing buffer |
| 259 | to an external file. It generalizes the Unix write(2) function. |
| 260 | It matches the streambuf::sys_write virtual function, which is |
| 261 | specific to this implementation. */ |
| 262 | typedef _IO_ssize_t (*_IO_write_t) (_IO_FILE *, const void *, _IO_ssize_t); |
| 263 | #define _IO_SYSWRITE(FP, DATA, LEN) JUMP2 (__write, FP, DATA, LEN) |
| 264 | #define _IO_WSYSWRITE(FP, DATA, LEN) WJUMP2 (__write, FP, DATA, LEN) |
| 265 | |
| 266 | /* The 'sysseek' hook is used to re-position an external file. |
| 267 | It generalizes the Unix lseek(2) function. |
| 268 | It matches the streambuf::sys_seek virtual function, which is |
| 269 | specific to this implementation. */ |
| 270 | typedef _IO_off64_t (*_IO_seek_t) (_IO_FILE *, _IO_off64_t, int); |
| 271 | #define _IO_SYSSEEK(FP, OFFSET, MODE) JUMP2 (__seek, FP, OFFSET, MODE) |
| 272 | #define _IO_WSYSSEEK(FP, OFFSET, MODE) WJUMP2 (__seek, FP, OFFSET, MODE) |
| 273 | |
| 274 | /* The 'sysclose' hook is used to finalize (close, finish up) an |
| 275 | external file. It generalizes the Unix close(2) function. |
| 276 | It matches the streambuf::sys_close virtual function, which is |
| 277 | specific to this implementation. */ |
| 278 | typedef int (*_IO_close_t) (_IO_FILE *); /* finalize */ |
| 279 | #define _IO_SYSCLOSE(FP) JUMP0 (__close, FP) |
| 280 | #define _IO_WSYSCLOSE(FP) WJUMP0 (__close, FP) |
| 281 | |
| 282 | /* The 'sysstat' hook is used to get information about an external file |
| 283 | into a struct stat buffer. It generalizes the Unix fstat(2) call. |
| 284 | It matches the streambuf::sys_stat virtual function, which is |
| 285 | specific to this implementation. */ |
| 286 | typedef int (*_IO_stat_t) (_IO_FILE *, void *); |
| 287 | #define _IO_SYSSTAT(FP, BUF) JUMP1 (__stat, FP, BUF) |
| 288 | #define _IO_WSYSSTAT(FP, BUF) WJUMP1 (__stat, FP, BUF) |
| 289 | |
| 290 | /* The 'showmany' hook can be used to get an image how much input is |
| 291 | available. In many cases the answer will be 0 which means unknown |
| 292 | but some cases one can provide real information. */ |
| 293 | typedef int (*_IO_showmanyc_t) (_IO_FILE *); |
| 294 | #define _IO_SHOWMANYC(FP) JUMP0 (__showmanyc, FP) |
| 295 | #define _IO_WSHOWMANYC(FP) WJUMP0 (__showmanyc, FP) |
| 296 | |
| 297 | /* The 'imbue' hook is used to get information about the currently |
| 298 | installed locales. */ |
| 299 | typedef void (*_IO_imbue_t) (_IO_FILE *, void *); |
| 300 | #define _IO_IMBUE(FP, LOCALE) JUMP1 (__imbue, FP, LOCALE) |
| 301 | #define _IO_WIMBUE(FP, LOCALE) WJUMP1 (__imbue, FP, LOCALE) |
| 302 | |
| 303 | |
| 304 | #define _IO_CHAR_TYPE char /* unsigned char ? */ |
| 305 | #define _IO_INT_TYPE int |
| 306 | |
| 307 | struct _IO_jump_t |
| 308 | { |
| 309 | JUMP_FIELD(size_t, __dummy); |
| 310 | JUMP_FIELD(size_t, __dummy2); |
| 311 | JUMP_FIELD(_IO_finish_t, __finish); |
| 312 | JUMP_FIELD(_IO_overflow_t, __overflow); |
| 313 | JUMP_FIELD(_IO_underflow_t, __underflow); |
| 314 | JUMP_FIELD(_IO_underflow_t, __uflow); |
| 315 | JUMP_FIELD(_IO_pbackfail_t, __pbackfail); |
| 316 | /* showmany */ |
| 317 | JUMP_FIELD(_IO_xsputn_t, __xsputn); |
| 318 | JUMP_FIELD(_IO_xsgetn_t, __xsgetn); |
| 319 | JUMP_FIELD(_IO_seekoff_t, __seekoff); |
| 320 | JUMP_FIELD(_IO_seekpos_t, __seekpos); |
| 321 | JUMP_FIELD(_IO_setbuf_t, __setbuf); |
| 322 | JUMP_FIELD(_IO_sync_t, __sync); |
| 323 | JUMP_FIELD(_IO_doallocate_t, __doallocate); |
| 324 | JUMP_FIELD(_IO_read_t, __read); |
| 325 | JUMP_FIELD(_IO_write_t, __write); |
| 326 | JUMP_FIELD(_IO_seek_t, __seek); |
| 327 | JUMP_FIELD(_IO_close_t, __close); |
| 328 | JUMP_FIELD(_IO_stat_t, __stat); |
| 329 | JUMP_FIELD(_IO_showmanyc_t, __showmanyc); |
| 330 | JUMP_FIELD(_IO_imbue_t, __imbue); |
| 331 | #if 0 |
| 332 | get_column; |
| 333 | set_column; |
| 334 | #endif |
| 335 | }; |
| 336 | |
| 337 | /* We always allocate an extra word following an _IO_FILE. |
| 338 | This contains a pointer to the function jump table used. |
| 339 | This is for compatibility with C++ streambuf; the word can |
| 340 | be used to smash to a pointer to a virtual function table. */ |
| 341 | |
| 342 | struct _IO_FILE_plus |
| 343 | { |
| 344 | _IO_FILE file; |
| 345 | const struct _IO_jump_t *vtable; |
| 346 | }; |
| 347 | |
| 348 | #ifdef _IO_USE_OLD_IO_FILE |
| 349 | /* This structure is used by the compatibility code as if it were an |
| 350 | _IO_FILE_plus, but has enough space to initialize the _mode argument |
| 351 | of an _IO_FILE_complete. */ |
| 352 | struct _IO_FILE_complete_plus |
| 353 | { |
| 354 | struct _IO_FILE_complete file; |
| 355 | const struct _IO_jump_t *vtable; |
| 356 | }; |
| 357 | #endif |
| 358 | |
| 359 | /* Special file type for fopencookie function. */ |
| 360 | struct _IO_cookie_file |
| 361 | { |
| 362 | struct _IO_FILE_plus __fp; |
| 363 | void *__cookie; |
| 364 | _IO_cookie_io_functions_t __io_functions; |
| 365 | }; |
| 366 | |
| 367 | _IO_FILE *_IO_fopencookie (void *cookie, const char *mode, |
| 368 | _IO_cookie_io_functions_t io_functions); |
| 369 | |
| 370 | |
| 371 | /* Iterator type for walking global linked list of _IO_FILE objects. */ |
| 372 | |
| 373 | typedef struct _IO_FILE *_IO_ITER; |
| 374 | |
| 375 | /* Generic functions */ |
| 376 | |
| 377 | extern void _IO_switch_to_main_get_area (_IO_FILE *) __THROW; |
| 378 | extern void _IO_switch_to_backup_area (_IO_FILE *) __THROW; |
| 379 | extern int _IO_switch_to_get_mode (_IO_FILE *); |
| 380 | libc_hidden_proto (_IO_switch_to_get_mode) |
| 381 | extern void _IO_init (_IO_FILE *, int) __THROW; |
| 382 | libc_hidden_proto (_IO_init) |
| 383 | extern int _IO_sputbackc (_IO_FILE *, int) __THROW; |
| 384 | libc_hidden_proto (_IO_sputbackc) |
| 385 | extern int _IO_sungetc (_IO_FILE *) __THROW; |
| 386 | extern void _IO_un_link (struct _IO_FILE_plus *) __THROW; |
| 387 | libc_hidden_proto (_IO_un_link) |
| 388 | extern void _IO_link_in (struct _IO_FILE_plus *) __THROW; |
| 389 | libc_hidden_proto (_IO_link_in) |
| 390 | extern void _IO_doallocbuf (_IO_FILE *) __THROW; |
| 391 | libc_hidden_proto (_IO_doallocbuf) |
| 392 | extern void _IO_unsave_markers (_IO_FILE *) __THROW; |
| 393 | libc_hidden_proto (_IO_unsave_markers) |
| 394 | extern void _IO_setb (_IO_FILE *, char *, char *, int) __THROW; |
| 395 | libc_hidden_proto (_IO_setb) |
| 396 | extern unsigned _IO_adjust_column (unsigned, const char *, int) __THROW; |
| 397 | libc_hidden_proto (_IO_adjust_column) |
| 398 | #define _IO_sputn(__fp, __s, __n) _IO_XSPUTN (__fp, __s, __n) |
| 399 | |
| 400 | _IO_ssize_t _IO_least_wmarker (_IO_FILE *, wchar_t *) __THROW; |
| 401 | libc_hidden_proto (_IO_least_wmarker) |
| 402 | extern void _IO_switch_to_main_wget_area (_IO_FILE *) __THROW; |
| 403 | libc_hidden_proto (_IO_switch_to_main_wget_area) |
| 404 | extern void _IO_switch_to_wbackup_area (_IO_FILE *) __THROW; |
| 405 | libc_hidden_proto (_IO_switch_to_wbackup_area) |
| 406 | extern int _IO_switch_to_wget_mode (_IO_FILE *); |
| 407 | libc_hidden_proto (_IO_switch_to_wget_mode) |
| 408 | extern void _IO_wsetb (_IO_FILE *, wchar_t *, wchar_t *, int) __THROW; |
| 409 | libc_hidden_proto (_IO_wsetb) |
| 410 | extern wint_t _IO_sputbackwc (_IO_FILE *, wint_t) __THROW; |
| 411 | libc_hidden_proto (_IO_sputbackwc) |
| 412 | extern wint_t _IO_sungetwc (_IO_FILE *) __THROW; |
| 413 | extern void _IO_wdoallocbuf (_IO_FILE *) __THROW; |
| 414 | libc_hidden_proto (_IO_wdoallocbuf) |
| 415 | extern void _IO_unsave_wmarkers (_IO_FILE *) __THROW; |
| 416 | extern unsigned _IO_adjust_wcolumn (unsigned, const wchar_t *, int) __THROW; |
| 417 | extern _IO_off64_t get_file_offset (_IO_FILE *fp); |
| 418 | |
| 419 | /* Marker-related function. */ |
| 420 | |
| 421 | extern void _IO_init_marker (struct _IO_marker *, _IO_FILE *); |
| 422 | extern void _IO_init_wmarker (struct _IO_marker *, _IO_FILE *); |
| 423 | extern void _IO_remove_marker (struct _IO_marker *) __THROW; |
| 424 | extern int _IO_marker_difference (struct _IO_marker *, struct _IO_marker *) |
| 425 | __THROW; |
| 426 | extern int _IO_marker_delta (struct _IO_marker *) __THROW; |
| 427 | extern int _IO_wmarker_delta (struct _IO_marker *) __THROW; |
| 428 | extern int _IO_seekmark (_IO_FILE *, struct _IO_marker *, int) __THROW; |
| 429 | extern int _IO_seekwmark (_IO_FILE *, struct _IO_marker *, int) __THROW; |
| 430 | |
| 431 | /* Functions for iterating global list and dealing with its lock */ |
| 432 | |
| 433 | extern _IO_ITER _IO_iter_begin (void) __THROW; |
| 434 | libc_hidden_proto (_IO_iter_begin) |
| 435 | extern _IO_ITER _IO_iter_end (void) __THROW; |
| 436 | libc_hidden_proto (_IO_iter_end) |
| 437 | extern _IO_ITER _IO_iter_next (_IO_ITER) __THROW; |
| 438 | libc_hidden_proto (_IO_iter_next) |
| 439 | extern _IO_FILE *_IO_iter_file (_IO_ITER) __THROW; |
| 440 | libc_hidden_proto (_IO_iter_file) |
| 441 | extern void _IO_list_lock (void) __THROW; |
| 442 | libc_hidden_proto (_IO_list_lock) |
| 443 | extern void _IO_list_unlock (void) __THROW; |
| 444 | libc_hidden_proto (_IO_list_unlock) |
| 445 | extern void _IO_list_resetlock (void) __THROW; |
| 446 | libc_hidden_proto (_IO_list_resetlock) |
| 447 | |
| 448 | /* Default jumptable functions. */ |
| 449 | |
| 450 | extern int _IO_default_underflow (_IO_FILE *) __THROW; |
| 451 | extern int _IO_default_uflow (_IO_FILE *); |
| 452 | libc_hidden_proto (_IO_default_uflow) |
| 453 | extern wint_t _IO_wdefault_uflow (_IO_FILE *); |
| 454 | libc_hidden_proto (_IO_wdefault_uflow) |
| 455 | extern int _IO_default_doallocate (_IO_FILE *) __THROW; |
| 456 | libc_hidden_proto (_IO_default_doallocate) |
| 457 | extern int _IO_wdefault_doallocate (_IO_FILE *) __THROW; |
| 458 | libc_hidden_proto (_IO_wdefault_doallocate) |
| 459 | extern void _IO_default_finish (_IO_FILE *, int) __THROW; |
| 460 | libc_hidden_proto (_IO_default_finish) |
| 461 | extern void _IO_wdefault_finish (_IO_FILE *, int) __THROW; |
| 462 | libc_hidden_proto (_IO_wdefault_finish) |
| 463 | extern int _IO_default_pbackfail (_IO_FILE *, int) __THROW; |
| 464 | libc_hidden_proto (_IO_default_pbackfail) |
| 465 | extern wint_t _IO_wdefault_pbackfail (_IO_FILE *, wint_t) __THROW; |
| 466 | libc_hidden_proto (_IO_wdefault_pbackfail) |
| 467 | extern _IO_FILE* _IO_default_setbuf (_IO_FILE *, char *, _IO_ssize_t); |
| 468 | extern _IO_size_t _IO_default_xsputn (_IO_FILE *, const void *, _IO_size_t); |
| 469 | libc_hidden_proto (_IO_default_xsputn) |
| 470 | extern _IO_size_t _IO_wdefault_xsputn (_IO_FILE *, const void *, _IO_size_t); |
| 471 | libc_hidden_proto (_IO_wdefault_xsputn) |
| 472 | extern _IO_size_t _IO_default_xsgetn (_IO_FILE *, void *, _IO_size_t); |
| 473 | libc_hidden_proto (_IO_default_xsgetn) |
| 474 | extern _IO_size_t _IO_wdefault_xsgetn (_IO_FILE *, void *, _IO_size_t); |
| 475 | libc_hidden_proto (_IO_wdefault_xsgetn) |
| 476 | extern _IO_off64_t _IO_default_seekoff (_IO_FILE *, _IO_off64_t, int, int) |
| 477 | __THROW; |
| 478 | extern _IO_off64_t _IO_default_seekpos (_IO_FILE *, _IO_off64_t, int); |
| 479 | extern _IO_ssize_t _IO_default_write (_IO_FILE *, const void *, _IO_ssize_t); |
| 480 | extern _IO_ssize_t _IO_default_read (_IO_FILE *, void *, _IO_ssize_t); |
| 481 | extern int _IO_default_stat (_IO_FILE *, void *) __THROW; |
| 482 | extern _IO_off64_t _IO_default_seek (_IO_FILE *, _IO_off64_t, int) __THROW; |
| 483 | extern int _IO_default_sync (_IO_FILE *) __THROW; |
| 484 | #define _IO_default_close ((_IO_close_t) _IO_default_sync) |
| 485 | extern int _IO_default_showmanyc (_IO_FILE *) __THROW; |
| 486 | extern void _IO_default_imbue (_IO_FILE *, void *) __THROW; |
| 487 | |
| 488 | extern const struct _IO_jump_t _IO_file_jumps; |
| 489 | libc_hidden_proto (_IO_file_jumps) |
| 490 | extern const struct _IO_jump_t _IO_file_jumps_mmap attribute_hidden; |
| 491 | extern const struct _IO_jump_t _IO_file_jumps_maybe_mmap attribute_hidden; |
| 492 | extern const struct _IO_jump_t _IO_wfile_jumps; |
| 493 | libc_hidden_proto (_IO_wfile_jumps) |
| 494 | extern const struct _IO_jump_t _IO_wfile_jumps_mmap attribute_hidden; |
| 495 | extern const struct _IO_jump_t _IO_wfile_jumps_maybe_mmap attribute_hidden; |
| 496 | extern const struct _IO_jump_t _IO_old_file_jumps attribute_hidden; |
| 497 | extern const struct _IO_jump_t _IO_streambuf_jumps; |
| 498 | extern const struct _IO_jump_t _IO_old_proc_jumps attribute_hidden; |
| 499 | extern const struct _IO_jump_t _IO_str_jumps attribute_hidden; |
| 500 | extern const struct _IO_jump_t _IO_wstr_jumps attribute_hidden; |
| 501 | extern const struct _IO_codecvt __libio_codecvt attribute_hidden; |
| 502 | extern int _IO_do_write (_IO_FILE *, const char *, _IO_size_t); |
| 503 | libc_hidden_proto (_IO_do_write) |
| 504 | extern int _IO_new_do_write (_IO_FILE *, const char *, _IO_size_t); |
| 505 | extern int _IO_old_do_write (_IO_FILE *, const char *, _IO_size_t); |
| 506 | extern int _IO_wdo_write (_IO_FILE *, const wchar_t *, _IO_size_t); |
| 507 | libc_hidden_proto (_IO_wdo_write) |
| 508 | extern int _IO_flush_all_lockp (int); |
| 509 | extern int _IO_flush_all (void); |
| 510 | libc_hidden_proto (_IO_flush_all) |
| 511 | extern int _IO_cleanup (void); |
| 512 | extern void _IO_flush_all_linebuffered (void); |
| 513 | libc_hidden_proto (_IO_flush_all_linebuffered) |
| 514 | extern int _IO_new_fgetpos (_IO_FILE *, _IO_fpos_t *); |
| 515 | extern int _IO_old_fgetpos (_IO_FILE *, _IO_fpos_t *); |
| 516 | extern int _IO_new_fsetpos (_IO_FILE *, const _IO_fpos_t *); |
| 517 | extern int _IO_old_fsetpos (_IO_FILE *, const _IO_fpos_t *); |
| 518 | extern int _IO_new_fgetpos64 (_IO_FILE *, _IO_fpos64_t *); |
| 519 | extern int _IO_old_fgetpos64 (_IO_FILE *, _IO_fpos64_t *); |
| 520 | extern int _IO_new_fsetpos64 (_IO_FILE *, const _IO_fpos64_t *); |
| 521 | extern int _IO_old_fsetpos64 (_IO_FILE *, const _IO_fpos64_t *); |
| 522 | extern void _IO_old_init (_IO_FILE *fp, int flags) __THROW; |
| 523 | |
| 524 | |
| 525 | #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T |
| 526 | # define _IO_do_flush(_f) \ |
| 527 | ((_f)->_mode <= 0 \ |
| 528 | ? _IO_do_write(_f, (_f)->_IO_write_base, \ |
| 529 | (_f)->_IO_write_ptr-(_f)->_IO_write_base) \ |
| 530 | : _IO_wdo_write(_f, (_f)->_wide_data->_IO_write_base, \ |
| 531 | ((_f)->_wide_data->_IO_write_ptr \ |
| 532 | - (_f)->_wide_data->_IO_write_base))) |
| 533 | #else |
| 534 | # define _IO_do_flush(_f) \ |
| 535 | _IO_do_write(_f, (_f)->_IO_write_base, \ |
| 536 | (_f)->_IO_write_ptr-(_f)->_IO_write_base) |
| 537 | #endif |
| 538 | #define _IO_old_do_flush(_f) \ |
| 539 | _IO_old_do_write(_f, (_f)->_IO_write_base, \ |
| 540 | (_f)->_IO_write_ptr-(_f)->_IO_write_base) |
| 541 | #define _IO_in_put_mode(_fp) ((_fp)->_flags & _IO_CURRENTLY_PUTTING) |
| 542 | #define _IO_mask_flags(fp, f, mask) \ |
| 543 | ((fp)->_flags = ((fp)->_flags & ~(mask)) | ((f) & (mask))) |
| 544 | #define _IO_setg(fp, eb, g, eg) ((fp)->_IO_read_base = (eb),\ |
| 545 | (fp)->_IO_read_ptr = (g), (fp)->_IO_read_end = (eg)) |
| 546 | #define _IO_wsetg(fp, eb, g, eg) ((fp)->_wide_data->_IO_read_base = (eb),\ |
| 547 | (fp)->_wide_data->_IO_read_ptr = (g), \ |
| 548 | (fp)->_wide_data->_IO_read_end = (eg)) |
| 549 | #define _IO_setp(__fp, __p, __ep) \ |
| 550 | ((__fp)->_IO_write_base = (__fp)->_IO_write_ptr \ |
| 551 | = __p, (__fp)->_IO_write_end = (__ep)) |
| 552 | #define _IO_wsetp(__fp, __p, __ep) \ |
| 553 | ((__fp)->_wide_data->_IO_write_base \ |
| 554 | = (__fp)->_wide_data->_IO_write_ptr = __p, \ |
| 555 | (__fp)->_wide_data->_IO_write_end = (__ep)) |
| 556 | #define _IO_have_backup(fp) ((fp)->_IO_save_base != NULL) |
| 557 | #define _IO_have_wbackup(fp) ((fp)->_wide_data->_IO_save_base != NULL) |
| 558 | #define _IO_in_backup(fp) ((fp)->_flags & _IO_IN_BACKUP) |
| 559 | #define _IO_have_markers(fp) ((fp)->_markers != NULL) |
| 560 | #define _IO_blen(fp) ((fp)->_IO_buf_end - (fp)->_IO_buf_base) |
| 561 | #define _IO_wblen(fp) ((fp)->_wide_data->_IO_buf_end \ |
| 562 | - (fp)->_wide_data->_IO_buf_base) |
| 563 | |
| 564 | /* Jumptable functions for files. */ |
| 565 | |
| 566 | extern int _IO_file_doallocate (_IO_FILE *) __THROW; |
| 567 | libc_hidden_proto (_IO_file_doallocate) |
| 568 | extern _IO_FILE* _IO_file_setbuf (_IO_FILE *, char *, _IO_ssize_t); |
| 569 | libc_hidden_proto (_IO_file_setbuf) |
| 570 | extern _IO_off64_t _IO_file_seekoff (_IO_FILE *, _IO_off64_t, int, int); |
| 571 | libc_hidden_proto (_IO_file_seekoff) |
| 572 | extern _IO_off64_t _IO_file_seekoff_mmap (_IO_FILE *, _IO_off64_t, int, int) |
| 573 | __THROW; |
| 574 | extern _IO_size_t _IO_file_xsputn (_IO_FILE *, const void *, _IO_size_t); |
| 575 | libc_hidden_proto (_IO_file_xsputn) |
| 576 | extern _IO_size_t _IO_file_xsgetn (_IO_FILE *, void *, _IO_size_t); |
| 577 | libc_hidden_proto (_IO_file_xsgetn) |
| 578 | extern int _IO_file_stat (_IO_FILE *, void *) __THROW; |
| 579 | libc_hidden_proto (_IO_file_stat) |
| 580 | extern int _IO_file_close (_IO_FILE *) __THROW; |
| 581 | libc_hidden_proto (_IO_file_close) |
| 582 | extern int _IO_file_close_mmap (_IO_FILE *) __THROW; |
| 583 | extern int _IO_file_underflow (_IO_FILE *); |
| 584 | libc_hidden_proto (_IO_file_underflow) |
| 585 | extern int _IO_file_underflow_mmap (_IO_FILE *); |
| 586 | extern int _IO_file_underflow_maybe_mmap (_IO_FILE *); |
| 587 | extern int _IO_file_overflow (_IO_FILE *, int); |
| 588 | libc_hidden_proto (_IO_file_overflow) |
| 589 | #define _IO_file_is_open(__fp) ((__fp)->_fileno != -1) |
| 590 | extern void _IO_file_init (struct _IO_FILE_plus *) __THROW; |
| 591 | libc_hidden_proto (_IO_file_init) |
| 592 | extern _IO_FILE* _IO_file_attach (_IO_FILE *, int); |
| 593 | libc_hidden_proto (_IO_file_attach) |
| 594 | extern _IO_FILE* _IO_file_open (_IO_FILE *, const char *, int, int, int, int); |
| 595 | libc_hidden_proto (_IO_file_open) |
| 596 | extern _IO_FILE* _IO_file_fopen (_IO_FILE *, const char *, const char *, int); |
| 597 | libc_hidden_proto (_IO_file_fopen) |
| 598 | extern _IO_ssize_t _IO_file_write (_IO_FILE *, const void *, _IO_ssize_t); |
| 599 | extern _IO_ssize_t _IO_file_read (_IO_FILE *, void *, _IO_ssize_t); |
| 600 | libc_hidden_proto (_IO_file_read) |
| 601 | extern int _IO_file_sync (_IO_FILE *); |
| 602 | libc_hidden_proto (_IO_file_sync) |
| 603 | extern int _IO_file_close_it (_IO_FILE *); |
| 604 | libc_hidden_proto (_IO_file_close_it) |
| 605 | extern _IO_off64_t _IO_file_seek (_IO_FILE *, _IO_off64_t, int) __THROW; |
| 606 | libc_hidden_proto (_IO_file_seek) |
| 607 | extern void _IO_file_finish (_IO_FILE *, int); |
| 608 | libc_hidden_proto (_IO_file_finish) |
| 609 | |
| 610 | extern _IO_FILE* _IO_new_file_attach (_IO_FILE *, int); |
| 611 | extern int _IO_new_file_close_it (_IO_FILE *); |
| 612 | extern void _IO_new_file_finish (_IO_FILE *, int); |
| 613 | extern _IO_FILE* _IO_new_file_fopen (_IO_FILE *, const char *, const char *, |
| 614 | int); |
| 615 | extern void _IO_no_init (_IO_FILE *, int, int, struct _IO_wide_data *, |
| 616 | const struct _IO_jump_t *) __THROW; |
| 617 | extern void _IO_new_file_init (struct _IO_FILE_plus *) __THROW; |
| 618 | extern _IO_FILE* _IO_new_file_setbuf (_IO_FILE *, char *, _IO_ssize_t); |
| 619 | extern _IO_FILE* _IO_file_setbuf_mmap (_IO_FILE *, char *, _IO_ssize_t); |
| 620 | extern int _IO_new_file_sync (_IO_FILE *); |
| 621 | extern int _IO_new_file_underflow (_IO_FILE *); |
| 622 | extern int _IO_new_file_overflow (_IO_FILE *, int); |
| 623 | extern _IO_off64_t _IO_new_file_seekoff (_IO_FILE *, _IO_off64_t, int, int); |
| 624 | extern _IO_ssize_t _IO_new_file_write (_IO_FILE *, const void *, _IO_ssize_t); |
| 625 | extern _IO_size_t _IO_new_file_xsputn (_IO_FILE *, const void *, _IO_size_t); |
| 626 | |
| 627 | extern _IO_FILE* _IO_old_file_setbuf (_IO_FILE *, char *, _IO_ssize_t); |
| 628 | extern _IO_off64_t _IO_old_file_seekoff (_IO_FILE *, _IO_off64_t, int, int); |
| 629 | extern _IO_size_t _IO_old_file_xsputn (_IO_FILE *, const void *, _IO_size_t); |
| 630 | extern int _IO_old_file_underflow (_IO_FILE *); |
| 631 | extern int _IO_old_file_overflow (_IO_FILE *, int); |
| 632 | extern void _IO_old_file_init (struct _IO_FILE_plus *) __THROW; |
| 633 | extern _IO_FILE* _IO_old_file_attach (_IO_FILE *, int); |
| 634 | extern _IO_FILE* _IO_old_file_fopen (_IO_FILE *, const char *, const char *); |
| 635 | extern _IO_ssize_t _IO_old_file_write (_IO_FILE *, const void *, _IO_ssize_t); |
| 636 | extern int _IO_old_file_sync (_IO_FILE *); |
| 637 | extern int _IO_old_file_close_it (_IO_FILE *); |
| 638 | extern void _IO_old_file_finish (_IO_FILE *, int); |
| 639 | |
| 640 | extern int _IO_wfile_doallocate (_IO_FILE *) __THROW; |
| 641 | extern _IO_size_t _IO_wfile_xsputn (_IO_FILE *, const void *, _IO_size_t); |
| 642 | libc_hidden_proto (_IO_wfile_xsputn) |
| 643 | extern _IO_FILE* _IO_wfile_setbuf (_IO_FILE *, wchar_t *, _IO_ssize_t); |
| 644 | extern wint_t _IO_wfile_sync (_IO_FILE *); |
| 645 | libc_hidden_proto (_IO_wfile_sync) |
| 646 | extern wint_t _IO_wfile_underflow (_IO_FILE *); |
| 647 | libc_hidden_proto (_IO_wfile_underflow) |
| 648 | extern wint_t _IO_wfile_overflow (_IO_FILE *, wint_t); |
| 649 | libc_hidden_proto (_IO_wfile_overflow) |
| 650 | extern _IO_off64_t _IO_wfile_seekoff (_IO_FILE *, _IO_off64_t, int, int); |
| 651 | libc_hidden_proto (_IO_wfile_seekoff) |
| 652 | |
| 653 | /* Jumptable functions for proc_files. */ |
| 654 | extern _IO_FILE* _IO_proc_open (_IO_FILE *, const char *, const char *) |
| 655 | __THROW; |
| 656 | extern _IO_FILE* _IO_new_proc_open (_IO_FILE *, const char *, const char *) |
| 657 | __THROW; |
| 658 | extern _IO_FILE* _IO_old_proc_open (_IO_FILE *, const char *, const char *); |
| 659 | extern int _IO_proc_close (_IO_FILE *) __THROW; |
| 660 | extern int _IO_new_proc_close (_IO_FILE *) __THROW; |
| 661 | extern int _IO_old_proc_close (_IO_FILE *); |
| 662 | |
| 663 | /* Jumptable functions for strfiles. */ |
| 664 | extern int _IO_str_underflow (_IO_FILE *) __THROW; |
| 665 | libc_hidden_proto (_IO_str_underflow) |
| 666 | extern int _IO_str_overflow (_IO_FILE *, int) __THROW; |
| 667 | libc_hidden_proto (_IO_str_overflow) |
| 668 | extern int _IO_str_pbackfail (_IO_FILE *, int) __THROW; |
| 669 | libc_hidden_proto (_IO_str_pbackfail) |
| 670 | extern _IO_off64_t _IO_str_seekoff (_IO_FILE *, _IO_off64_t, int, int) __THROW; |
| 671 | libc_hidden_proto (_IO_str_seekoff) |
| 672 | extern void _IO_str_finish (_IO_FILE *, int) __THROW; |
| 673 | |
| 674 | /* Other strfile functions */ |
| 675 | struct _IO_strfile_; |
| 676 | extern void _IO_str_init_static (struct _IO_strfile_ *, char *, int, char *) |
| 677 | __THROW; |
| 678 | extern void _IO_str_init_readonly (struct _IO_strfile_ *, const char *, int) |
| 679 | __THROW; |
| 680 | extern _IO_ssize_t _IO_str_count (_IO_FILE *) __THROW; |
| 681 | |
| 682 | /* And the wide character versions. */ |
| 683 | extern void _IO_wstr_init_static (_IO_FILE *, wchar_t *, _IO_size_t, wchar_t *) |
| 684 | __THROW; |
| 685 | extern _IO_ssize_t _IO_wstr_count (_IO_FILE *) __THROW; |
| 686 | extern _IO_wint_t _IO_wstr_overflow (_IO_FILE *, _IO_wint_t) __THROW; |
| 687 | extern _IO_wint_t _IO_wstr_underflow (_IO_FILE *) __THROW; |
| 688 | extern _IO_off64_t _IO_wstr_seekoff (_IO_FILE *, _IO_off64_t, int, int) |
| 689 | __THROW; |
| 690 | extern _IO_wint_t _IO_wstr_pbackfail (_IO_FILE *, _IO_wint_t) __THROW; |
| 691 | extern void _IO_wstr_finish (_IO_FILE *, int) __THROW; |
| 692 | |
| 693 | extern int _IO_vasprintf (char **result_ptr, const char *format, |
| 694 | _IO_va_list args) __THROW; |
| 695 | extern int _IO_vdprintf (int d, const char *format, _IO_va_list arg); |
| 696 | extern int _IO_vsnprintf (char *string, _IO_size_t maxlen, |
| 697 | const char *format, _IO_va_list args) __THROW; |
| 698 | |
| 699 | |
| 700 | extern _IO_size_t _IO_getline (_IO_FILE *,char *, _IO_size_t, int, int); |
| 701 | libc_hidden_proto (_IO_getline) |
| 702 | extern _IO_size_t _IO_getline_info (_IO_FILE *,char *, _IO_size_t, |
| 703 | int, int, int *); |
| 704 | libc_hidden_proto (_IO_getline_info) |
| 705 | extern _IO_ssize_t _IO_getdelim (char **, _IO_size_t *, int, _IO_FILE *); |
| 706 | extern _IO_size_t _IO_getwline (_IO_FILE *,wchar_t *, _IO_size_t, wint_t, int); |
| 707 | extern _IO_size_t _IO_getwline_info (_IO_FILE *,wchar_t *, _IO_size_t, |
| 708 | wint_t, int, wint_t *); |
| 709 | |
| 710 | extern struct _IO_FILE_plus *_IO_list_all; |
| 711 | libc_hidden_proto (_IO_list_all) |
| 712 | extern void (*_IO_cleanup_registration_needed) (void); |
| 713 | |
| 714 | extern void _IO_str_init_static_internal (struct _IO_strfile_ *, char *, |
| 715 | _IO_size_t, char *) __THROW; |
| 716 | extern _IO_off64_t _IO_seekoff_unlocked (_IO_FILE *, _IO_off64_t, int, int) |
| 717 | attribute_hidden; |
| 718 | extern _IO_off64_t _IO_seekpos_unlocked (_IO_FILE *, _IO_off64_t, int) |
| 719 | attribute_hidden; |
| 720 | |
| 721 | #ifndef EOF |
| 722 | # define EOF (-1) |
| 723 | #endif |
| 724 | #ifndef NULL |
| 725 | # if defined __GNUG__ && \ |
| 726 | (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 8)) |
| 727 | # define NULL (__null) |
| 728 | # else |
| 729 | # if !defined(__cplusplus) |
| 730 | # define NULL ((void*)0) |
| 731 | # else |
| 732 | # define NULL (0) |
| 733 | # endif |
| 734 | # endif |
| 735 | #endif |
| 736 | |
| 737 | #if _G_HAVE_MMAP |
| 738 | |
| 739 | # include <unistd.h> |
| 740 | # include <fcntl.h> |
| 741 | # include <sys/mman.h> |
| 742 | # include <sys/param.h> |
| 743 | |
| 744 | # if !defined(MAP_ANONYMOUS) && defined(MAP_ANON) |
| 745 | # define MAP_ANONYMOUS MAP_ANON |
| 746 | # endif |
| 747 | |
| 748 | # if !defined(MAP_ANONYMOUS) || !defined(EXEC_PAGESIZE) |
| 749 | # undef _G_HAVE_MMAP |
| 750 | # define _G_HAVE_MMAP 0 |
| 751 | # endif |
| 752 | |
| 753 | #endif /* _G_HAVE_MMAP */ |
| 754 | |
| 755 | #if _G_HAVE_MMAP |
| 756 | |
| 757 | # ifdef _LIBC |
| 758 | /* When using this code in the GNU libc we must not pollute the name space. */ |
| 759 | # define mmap __mmap |
| 760 | # define munmap __munmap |
| 761 | # define ftruncate __ftruncate |
| 762 | # endif |
| 763 | |
| 764 | # define ROUND_TO_PAGE(_S) \ |
| 765 | (((_S) + EXEC_PAGESIZE - 1) & ~(EXEC_PAGESIZE - 1)) |
| 766 | |
| 767 | # define FREE_BUF(_B, _S) \ |
| 768 | munmap ((_B), ROUND_TO_PAGE (_S)) |
| 769 | # define ALLOC_BUF(_B, _S, _R) \ |
| 770 | do { \ |
| 771 | (_B) = (char *) mmap (0, ROUND_TO_PAGE (_S), \ |
| 772 | PROT_READ | PROT_WRITE, \ |
| 773 | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); \ |
| 774 | if ((_B) == (char *) MAP_FAILED) \ |
| 775 | return (_R); \ |
| 776 | } while (0) |
| 777 | # define ALLOC_WBUF(_B, _S, _R) \ |
| 778 | do { \ |
| 779 | (_B) = (wchar_t *) mmap (0, ROUND_TO_PAGE (_S), \ |
| 780 | PROT_READ | PROT_WRITE, \ |
| 781 | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); \ |
| 782 | if ((_B) == (wchar_t *) MAP_FAILED) \ |
| 783 | return (_R); \ |
| 784 | } while (0) |
| 785 | |
| 786 | #else /* _G_HAVE_MMAP */ |
| 787 | |
| 788 | # define FREE_BUF(_B, _S) \ |
| 789 | free(_B) |
| 790 | # define ALLOC_BUF(_B, _S, _R) \ |
| 791 | do { \ |
| 792 | (_B) = (char*)malloc(_S); \ |
| 793 | if ((_B) == NULL) \ |
| 794 | return (_R); \ |
| 795 | } while (0) |
| 796 | # define ALLOC_WBUF(_B, _S, _R) \ |
| 797 | do { \ |
| 798 | (_B) = (wchar_t *)malloc(_S); \ |
| 799 | if ((_B) == NULL) \ |
| 800 | return (_R); \ |
| 801 | } while (0) |
| 802 | |
| 803 | #endif /* _G_HAVE_MMAP */ |
| 804 | |
| 805 | #ifndef OS_FSTAT |
| 806 | # define OS_FSTAT fstat |
| 807 | #endif |
| 808 | extern int _IO_vscanf (const char *, _IO_va_list) __THROW; |
| 809 | |
| 810 | /* _IO_pos_BAD is an _IO_off64_t value indicating error, unknown, or EOF. */ |
| 811 | #ifndef _IO_pos_BAD |
| 812 | # define _IO_pos_BAD ((_IO_off64_t) -1) |
| 813 | #endif |
| 814 | /* _IO_pos_adjust adjust an _IO_off64_t by some number of bytes. */ |
| 815 | #ifndef _IO_pos_adjust |
| 816 | # define _IO_pos_adjust(pos, delta) ((pos) += (delta)) |
| 817 | #endif |
| 818 | /* _IO_pos_0 is an _IO_off64_t value indicating beginning of file. */ |
| 819 | #ifndef _IO_pos_0 |
| 820 | # define _IO_pos_0 ((_IO_off64_t) 0) |
| 821 | #endif |
| 822 | |
| 823 | #ifdef __cplusplus |
| 824 | } |
| 825 | #endif |
| 826 | |
| 827 | #ifdef _IO_MTSAFE_IO |
| 828 | /* check following! */ |
| 829 | # ifdef _IO_USE_OLD_IO_FILE |
| 830 | # define FILEBUF_LITERAL(CHAIN, FLAGS, FD, WDP) \ |
| 831 | { _IO_MAGIC+_IO_LINKED+_IO_IS_FILEBUF+FLAGS, \ |
| 832 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (_IO_FILE *) CHAIN, FD, \ |
| 833 | 0, _IO_pos_BAD, 0, 0, { 0 }, &_IO_stdfile_##FD##_lock } |
| 834 | # else |
| 835 | # if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T |
| 836 | # define FILEBUF_LITERAL(CHAIN, FLAGS, FD, WDP) \ |
| 837 | { _IO_MAGIC+_IO_LINKED+_IO_IS_FILEBUF+FLAGS, \ |
| 838 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (_IO_FILE *) CHAIN, FD, \ |
| 839 | 0, _IO_pos_BAD, 0, 0, { 0 }, &_IO_stdfile_##FD##_lock, _IO_pos_BAD,\ |
| 840 | NULL, WDP, 0 } |
| 841 | # else |
| 842 | # define FILEBUF_LITERAL(CHAIN, FLAGS, FD, WDP) \ |
| 843 | { _IO_MAGIC+_IO_LINKED+_IO_IS_FILEBUF+FLAGS, \ |
| 844 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (_IO_FILE *) CHAIN, FD, \ |
| 845 | 0, _IO_pos_BAD, 0, 0, { 0 }, &_IO_stdfile_##FD##_lock, _IO_pos_BAD,\ |
| 846 | 0 } |
| 847 | # endif |
| 848 | # endif |
| 849 | #else |
| 850 | # ifdef _IO_USE_OLD_IO_FILE |
| 851 | # define FILEBUF_LITERAL(CHAIN, FLAGS, FD, WDP) \ |
| 852 | { _IO_MAGIC+_IO_LINKED+_IO_IS_FILEBUF+FLAGS, \ |
| 853 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (_IO_FILE *) CHAIN, FD, \ |
| 854 | 0, _IO_pos_BAD } |
| 855 | # else |
| 856 | # if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T |
| 857 | # define FILEBUF_LITERAL(CHAIN, FLAGS, FD, WDP) \ |
| 858 | { _IO_MAGIC+_IO_LINKED+_IO_IS_FILEBUF+FLAGS, \ |
| 859 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (_IO_FILE *) CHAIN, FD, \ |
| 860 | 0, _IO_pos_BAD, 0, 0, { 0 }, 0, _IO_pos_BAD, \ |
| 861 | NULL, WDP, 0 } |
| 862 | # else |
| 863 | # define FILEBUF_LITERAL(CHAIN, FLAGS, FD, WDP) \ |
| 864 | { _IO_MAGIC+_IO_LINKED+_IO_IS_FILEBUF+FLAGS, \ |
| 865 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (_IO_FILE *) CHAIN, FD, \ |
| 866 | 0, _IO_pos_BAD, 0, 0, { 0 }, 0, _IO_pos_BAD, \ |
| 867 | 0 } |
| 868 | # endif |
| 869 | # endif |
| 870 | #endif |
| 871 | |
| 872 | #define _IO_va_start(args, last) va_start(args, last) |
| 873 | |
| 874 | extern struct _IO_fake_stdiobuf _IO_stdin_buf, _IO_stdout_buf, _IO_stderr_buf; |
| 875 | |
| 876 | #if 1 |
| 877 | # define COERCE_FILE(FILE) /* Nothing */ |
| 878 | #else |
| 879 | /* This is part of the kludge for binary compatibility with old stdio. */ |
| 880 | # define COERCE_FILE(FILE) \ |
| 881 | (((FILE)->_IO_file_flags & _IO_MAGIC_MASK) == _OLD_MAGIC_MASK \ |
| 882 | && (FILE) = *(FILE**)&((int*)fp)[1]) |
| 883 | #endif |
| 884 | |
| 885 | #ifdef EINVAL |
| 886 | # define MAYBE_SET_EINVAL __set_errno (EINVAL) |
| 887 | #else |
| 888 | # define MAYBE_SET_EINVAL /* nothing */ |
| 889 | #endif |
| 890 | |
| 891 | #ifdef IO_DEBUG |
| 892 | # define CHECK_FILE(FILE, RET) \ |
| 893 | if ((FILE) == NULL) { MAYBE_SET_EINVAL; return RET; } \ |
| 894 | else { COERCE_FILE(FILE); \ |
| 895 | if (((FILE)->_IO_file_flags & _IO_MAGIC_MASK) != _IO_MAGIC) \ |
| 896 | { MAYBE_SET_EINVAL; return RET; }} |
| 897 | #else |
| 898 | # define CHECK_FILE(FILE, RET) COERCE_FILE (FILE) |
| 899 | #endif |
| 900 | |
| 901 | static inline void |
| 902 | __attribute__ ((__always_inline__)) |
| 903 | _IO_acquire_lock_fct (_IO_FILE **p) |
| 904 | { |
| 905 | _IO_FILE *fp = *p; |
| 906 | if ((fp->_flags & _IO_USER_LOCK) == 0) |
| 907 | _IO_funlockfile (fp); |
| 908 | } |
| 909 | |
| 910 | static inline void |
| 911 | __attribute__ ((__always_inline__)) |
| 912 | _IO_acquire_lock_clear_flags2_fct (_IO_FILE **p) |
| 913 | { |
| 914 | _IO_FILE *fp = *p; |
| 915 | fp->_flags2 &= ~(_IO_FLAGS2_FORTIFY | _IO_FLAGS2_SCANF_STD); |
| 916 | if ((fp->_flags & _IO_USER_LOCK) == 0) |
| 917 | _IO_funlockfile (fp); |
| 918 | } |
| 919 | |
| 920 | #if !defined _IO_MTSAFE_IO && IS_IN (libc) |
| 921 | # define _IO_acquire_lock(_fp) \ |
| 922 | do { \ |
| 923 | _IO_FILE *_IO_acquire_lock_file = NULL |
| 924 | # define _IO_acquire_lock_clear_flags2(_fp) \ |
| 925 | do { \ |
| 926 | _IO_FILE *_IO_acquire_lock_file = (_fp) |
| 927 | # define _IO_release_lock(_fp) \ |
| 928 | if (_IO_acquire_lock_file != NULL) \ |
| 929 | _IO_acquire_lock_file->_flags2 &= ~(_IO_FLAGS2_FORTIFY \ |
| 930 | | _IO_FLAGS2_SCANF_STD); \ |
| 931 | } while (0) |
| 932 | #endif |