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