]>
Commit | Line | Data |
---|---|---|
96aa2d94 RM |
1 | /* |
2 | Copyright (C) 1993 Free Software Foundation | |
3 | ||
4 | This file is part of the GNU IO Library. This library is free | |
5 | software; you can redistribute it and/or modify it under the | |
6 | terms of the GNU General Public License as published by the | |
7 | Free Software Foundation; either version 2, or (at your option) | |
8 | any later version. | |
9 | ||
10 | This library is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | GNU General Public License for more details. | |
14 | ||
15 | You should have received a copy of the GNU General Public License | |
16 | along with this library; see the file COPYING. If not, write to the Free | |
17 | Software Foundation, 59 Temple Place - Suite 330, Boston, 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 not cause | |
21 | the resulting executable to be covered by the GNU General Public License. | |
22 | This exception does not however invalidate any other reasons why | |
23 | the executable file might be covered by the GNU General Public License. */ | |
24 | ||
25 | #include <errno.h> | |
26 | #ifndef errno | |
27 | extern int errno; | |
28 | #endif | |
edf5b2d7 | 29 | #include <libc-lock.h> |
96aa2d94 RM |
30 | |
31 | #include "iolibio.h" | |
32 | ||
33 | #if defined (__STDC__) || defined (_AIX) || (defined (__mips) && defined (_SYSTYPE_SVR4)) || defined(__cplusplus) | |
34 | /* All known AIX compilers implement these things (but don't always | |
35 | define __STDC__). The RISC/OS MIPS compiler defines these things | |
36 | in SVR4 mode, but does not define __STDC__. */ | |
37 | ||
38 | #define AND , | |
39 | #define DEFUN(name, arglist, args) name(args) | |
40 | #define DEFUN_VOID(name) name(void) | |
41 | ||
42 | #else /* Not ANSI C. */ | |
43 | ||
44 | #define AND ; | |
45 | #ifndef const /* some systems define it in header files for non-ansi mode */ | |
46 | #define const | |
47 | #endif | |
48 | #define DEFUN(name, arglist, args) name arglist args; | |
49 | #define DEFUN_VOID(name) name() | |
50 | #endif /* ANSI C. */ | |
51 | ||
52 | #ifdef __cplusplus | |
53 | extern "C" { | |
54 | #endif | |
55 | ||
56 | #define _IO_seek_set 0 | |
57 | #define _IO_seek_cur 1 | |
58 | #define _IO_seek_end 2 | |
59 | ||
f65fd747 UD |
60 | /* THE JUMPTABLE FUNCTIONS. |
61 | ||
62 | * The _IO_FILE type is used to implement the FILE type in GNU libc, | |
63 | * as well as the streambuf class in GNU iostreams for C++. | |
64 | * These are all the same, just used differently. | |
65 | * An _IO_FILE (or FILE) object is allows followed by a pointer to | |
66 | * a jump table (of pointers to functions). The pointer is accessed | |
67 | * with the _IO_JUMPS macro. The jump table has a eccentric format, | |
68 | * so as to be compatible with the layout of a C++ virtual function table. | |
69 | * (as implemented by g++). When a pointer to a steambuf object is | |
70 | * coerced to an (_IO_FILE*), then _IO_JUMPS on the result just | |
71 | * happens to point to the virtual function table of the streambuf. | |
72 | * Thus the _IO_JUMPS function table used for C stdio/libio does | |
73 | * double duty as the virtual functiuon table for C++ streambuf. | |
74 | * | |
75 | * The entries in the _IO_JUMPS function table (and hence also the | |
76 | * virtual functions of a streambuf) are described below. | |
77 | * The first parameter of each function entry is the _IO_FILE/streambuf | |
78 | * object being acted on (i.e. the 'this' parameter). | |
79 | */ | |
96aa2d94 | 80 | |
96aa2d94 | 81 | #define _IO_JUMPS(THIS) ((struct _IO_FILE_plus*)(THIS))->vtable |
f65fd747 | 82 | #ifdef _G_USING_THUNKS |
96aa2d94 RM |
83 | #define JUMP_FIELD(TYPE, NAME) TYPE NAME |
84 | #define JUMP0(FUNC, THIS) _IO_JUMPS(THIS)->FUNC(THIS) | |
85 | #define JUMP1(FUNC, THIS, X1) _IO_JUMPS(THIS)->FUNC(THIS, X1) | |
86 | #define JUMP2(FUNC, THIS, X1, X2) _IO_JUMPS(THIS)->FUNC(THIS, X1, X2) | |
f65fd747 | 87 | #define JUMP3(FUNC, THIS, X1,X2,X3) _IO_JUMPS(THIS)->FUNC(THIS, X1,X2, X3) |
96aa2d94 | 88 | #define JUMP_INIT(NAME, VALUE) VALUE |
f65fd747 | 89 | #define JUMP_INIT_DUMMY JUMP_INIT(dummy, 0), JUMP_INIT(dummy2, 0) |
96aa2d94 | 90 | #else |
f65fd747 | 91 | /* These macros will change when we re-implement vtables to use "thunks"! */ |
96aa2d94 RM |
92 | #define JUMP_FIELD(TYPE, NAME) struct { short delta1, delta2; TYPE pfn; } NAME |
93 | #define JUMP0(FUNC, THIS) _IO_JUMPS(THIS)->FUNC.pfn(THIS) | |
94 | #define JUMP1(FUNC, THIS, X1) _IO_JUMPS(THIS)->FUNC.pfn(THIS, X1) | |
95 | #define JUMP2(FUNC, THIS, X1, X2) _IO_JUMPS(THIS)->FUNC.pfn(THIS, X1, X2) | |
96 | #define JUMP3(FUNC, THIS, X1,X2,X3) _IO_JUMPS(THIS)->FUNC.pfn(THIS, X1,X2, X3) | |
97 | #define JUMP_INIT(NAME, VALUE) {0, 0, VALUE} | |
96aa2d94 | 98 | #define JUMP_INIT_DUMMY JUMP_INIT(dummy, 0) |
f65fd747 | 99 | #endif |
96aa2d94 | 100 | |
f65fd747 UD |
101 | /* The 'finish' function does any final cleaning up of an _IO_FILE object. |
102 | It does not delete (free) it, but does everything else to finalize it/ | |
103 | It matches the streambuf::~streambuf virtual destructor. */ | |
104 | typedef void (*_IO_finish_t) __P((_IO_FILE*)); /* finalize */ | |
96aa2d94 | 105 | #define _IO_FINISH(FP) JUMP0(__finish, FP) |
f65fd747 UD |
106 | |
107 | /* The 'overflow' hook flushes the buffer. | |
108 | The second argument is a character, or EOF. | |
109 | It matches the streambuf::overflow virtual function. */ | |
110 | typedef int (*_IO_overflow_t) __P((_IO_FILE*, int)); | |
96aa2d94 | 111 | #define _IO_OVERFLOW(FP, CH) JUMP1(__overflow, FP, CH) |
f65fd747 UD |
112 | |
113 | /* The 'underflow' hook tries to fills the get buffer. | |
114 | It returns the next character (as an unsigned char) or EOF. The next | |
115 | character remains in the get buffer, and the get postion is not changed. | |
116 | It matches the streambuf::underflow virtual function. */ | |
117 | typedef int (*_IO_underflow_t) __P((_IO_FILE*)); | |
96aa2d94 | 118 | #define _IO_UNDERFLOW(FP) JUMP0(__underflow, FP) |
f65fd747 UD |
119 | |
120 | /* The 'uflow' hook returns the next character in the input stream | |
121 | (cast to unsigned char), and increments the read position; | |
122 | EOF is returned on failure. | |
123 | It matches the streambuf::uflow virtual function, which is not in the | |
124 | cfront implementation, but was added to C++ by the ANSI/ISO committee. */ | |
96aa2d94 | 125 | #define _IO_UFLOW(FP) JUMP0(__uflow, FP) |
f65fd747 UD |
126 | |
127 | /* The 'pbackfail' hook handles backing up. | |
128 | It matches the streambuf::pbackfail virtual function. */ | |
129 | typedef int (*_IO_pbackfail_t) __P((_IO_FILE*, int)); | |
96aa2d94 | 130 | #define _IO_PBACKFAIL(FP, CH) JUMP1(__pbackfail, FP, CH) |
f65fd747 UD |
131 | |
132 | /* The 'xsputn' hook writes upto N characters from buffer DATA. | |
133 | Returns the number of character actually written. | |
134 | It matches the streambuf::xsputn virtual function. */ | |
135 | typedef _IO_size_t (*_IO_xsputn_t) | |
136 | __P((_IO_FILE *FP, const void *DATA, _IO_size_t N)); | |
96aa2d94 | 137 | #define _IO_XSPUTN(FP, DATA, N) JUMP2(__xsputn, FP, DATA, N) |
f65fd747 UD |
138 | |
139 | /* The 'xsgetn' hook reads upto N characters into buffer DATA. | |
140 | Returns the number of character actually read. | |
141 | It matches the streambuf::xsgetn virtual function. */ | |
142 | typedef _IO_size_t (*_IO_xsgetn_t) __P((_IO_FILE*FP, void*DATA, _IO_size_t N)); | |
96aa2d94 | 143 | #define _IO_XSGETN(FP, DATA, N) JUMP2(__xsgetn, FP, DATA, N) |
f65fd747 UD |
144 | |
145 | /* The 'seekoff' hook moves the stream position to a new position | |
146 | relative to the start of the file (if DIR==0), the current position | |
147 | (MODE==1), or the end of the file (MODE==2). | |
148 | It matches the streambuf::seekoff virtual function. | |
149 | It is also used for the ANSI fseek function. */ | |
150 | typedef _IO_fpos_t (*_IO_seekoff_t) | |
151 | __P((_IO_FILE* FP, _IO_off_t OFF, int DIR, int MODE)); | |
96aa2d94 | 152 | #define _IO_SEEKOFF(FP, OFF, DIR, MODE) JUMP3(__seekoff, FP, OFF, DIR, MODE) |
f65fd747 UD |
153 | |
154 | /* The 'seekpos' hook also moves the stream position, | |
155 | but to an absolute position given by a fpos_t (seekpos). | |
156 | It matches the streambuf::seekpos virtual function. | |
157 | It is also used for the ANSI fgetpos and fsetpos functions. */ | |
158 | /* The _IO_seek_cur and _IO_seek_end options are not allowed. */ | |
159 | typedef _IO_fpos_t (*_IO_seekpos_t) __P((_IO_FILE*, _IO_fpos_t, int)); | |
96aa2d94 | 160 | #define _IO_SEEKPOS(FP, POS, FLAGS) JUMP2(__seekpos, FP, POS, FLAGS) |
f65fd747 UD |
161 | |
162 | /* The 'setbuf' hook gives a buffer to the file. | |
163 | It matches the streambuf::setbuf virtual function. */ | |
164 | typedef _IO_FILE* (*_IO_setbuf_t) __P((_IO_FILE*, char *, _IO_ssize_t)); | |
96aa2d94 | 165 | #define _IO_SETBUF(FP, BUFFER, LENGTH) JUMP2(__setbuf, FP, BUFFER, LENGTH) |
f65fd747 UD |
166 | |
167 | /* The 'sync' hook attempts to synchronize the internal data structures | |
168 | of the file with the external state. | |
169 | It matches the streambuf::sync virtual function. */ | |
170 | typedef int (*_IO_sync_t) __P((_IO_FILE*)); | |
96aa2d94 | 171 | #define _IO_SYNC(FP) JUMP0(__sync, FP) |
f65fd747 UD |
172 | |
173 | /* The 'doallocate' hook is used to tell the file to allocate a buffer. | |
174 | It matches the streambuf::doallocate virtual function, which is not | |
175 | in the ANSI/ISO C++ standard, but is part traditional implementations. */ | |
176 | typedef int (*_IO_doallocate_t) __P((_IO_FILE*)); | |
96aa2d94 | 177 | #define _IO_DOALLOCATE(FP) JUMP0(__doallocate, FP) |
f65fd747 UD |
178 | |
179 | /* The following four hooks (sysread, syswrite, sysclose, sysseek, and | |
180 | sysstat) are low-level hooks specific to this implementation. | |
181 | There is no correspondance in the ANSI/ISO C++ standard library. | |
182 | The hooks basically correspond to the Unix system functions | |
183 | (read, write, close, lseek, and stat) except that a _IO_FILE* | |
184 | parameter is used instead of a integer file descriptor; the default | |
185 | implementation used for normal files just calls those functions. | |
186 | The advantage of overriding these functions instead of the higher-level | |
187 | ones (underflow, overflow etc) is that you can leave all the buffering | |
188 | higher-level functions. */ | |
189 | ||
190 | /* The 'sysread' hook is used to read data from the external file into | |
191 | an existing buffer. It generalizes the Unix read(2) function. | |
192 | It matches the streambuf::sys_read virtual function, which is | |
193 | specific to this implementaion. */ | |
194 | typedef _IO_ssize_t (*_IO_read_t) __P((_IO_FILE*, void*, _IO_ssize_t)); | |
96aa2d94 | 195 | #define _IO_SYSREAD(FP, DATA, LEN) JUMP2(__read, FP, DATA, LEN) |
f65fd747 UD |
196 | |
197 | /* The 'syswrite' hook is used to write data from an existing buffer | |
198 | to an external file. It generalizes the Unix write(2) function. | |
199 | It matches the streambuf::sys_write virtual function, which is | |
200 | specific to this implementaion. */ | |
201 | typedef _IO_ssize_t (*_IO_write_t) __P((_IO_FILE*,const void*,_IO_ssize_t)); | |
96aa2d94 | 202 | #define _IO_SYSWRITE(FP, DATA, LEN) JUMP2(__write, FP, DATA, LEN) |
f65fd747 UD |
203 | |
204 | /* The 'sysseek' hook is used to re-position an external file. | |
205 | It generalizes the Unix lseek(2) function. | |
206 | It matches the streambuf::sys_seek virtual function, which is | |
207 | specific to this implementaion. */ | |
208 | typedef _IO_fpos_t (*_IO_seek_t) __P((_IO_FILE*, _IO_off_t, int)); | |
96aa2d94 | 209 | #define _IO_SYSSEEK(FP, OFFSET, MODE) JUMP2(__seek, FP, OFFSET, MODE) |
f65fd747 UD |
210 | |
211 | /* The 'sysclose' hook is used to finalize (close, finish up) an | |
212 | external file. It generalizes the Unix close(2) function. | |
213 | It matches the streambuf::sys_close virtual function, which is | |
214 | specific to this implementation. */ | |
215 | typedef int (*_IO_close_t) __P((_IO_FILE*)); /* finalize */ | |
96aa2d94 | 216 | #define _IO_SYSCLOSE(FP) JUMP0(__close, FP) |
f65fd747 UD |
217 | |
218 | /* The 'sysstat' hook is used to get information about an external file | |
219 | into a struct stat buffer. It generalizes the Unix fstat(2) call. | |
220 | It matches the streambuf::sys_stat virtual function, which is | |
221 | specific to this implementaion. */ | |
222 | typedef int (*_IO_stat_t) __P((_IO_FILE*, void*)); | |
96aa2d94 RM |
223 | #define _IO_SYSSTAT(FP, BUF) JUMP1(__stat, FP, BUF) |
224 | ||
f65fd747 | 225 | |
96aa2d94 RM |
226 | #define _IO_CHAR_TYPE char /* unsigned char ? */ |
227 | #define _IO_INT_TYPE int | |
228 | ||
229 | struct _IO_jump_t { | |
230 | JUMP_FIELD(_G_size_t, __dummy); | |
f65fd747 UD |
231 | #ifdef _G_USING_THUNKS |
232 | JUMP_FIELD(_G_size_t, __dummy2); | |
233 | #endif | |
96aa2d94 RM |
234 | JUMP_FIELD(_IO_finish_t, __finish); |
235 | JUMP_FIELD(_IO_overflow_t, __overflow); | |
236 | JUMP_FIELD(_IO_underflow_t, __underflow); | |
237 | JUMP_FIELD(_IO_underflow_t, __uflow); | |
238 | JUMP_FIELD(_IO_pbackfail_t, __pbackfail); | |
239 | /* showmany */ | |
240 | JUMP_FIELD(_IO_xsputn_t, __xsputn); | |
241 | JUMP_FIELD(_IO_xsgetn_t, __xsgetn); | |
242 | JUMP_FIELD(_IO_seekoff_t, __seekoff); | |
243 | JUMP_FIELD(_IO_seekpos_t, __seekpos); | |
244 | JUMP_FIELD(_IO_setbuf_t, __setbuf); | |
245 | JUMP_FIELD(_IO_sync_t, __sync); | |
246 | JUMP_FIELD(_IO_doallocate_t, __doallocate); | |
247 | JUMP_FIELD(_IO_read_t, __read); | |
248 | JUMP_FIELD(_IO_write_t, __write); | |
249 | JUMP_FIELD(_IO_seek_t, __seek); | |
250 | JUMP_FIELD(_IO_close_t, __close); | |
251 | JUMP_FIELD(_IO_stat_t, __stat); | |
252 | #if 0 | |
253 | get_column; | |
254 | set_column; | |
255 | #endif | |
256 | }; | |
257 | ||
258 | /* We always allocate an extra word following an _IO_FILE. | |
f65fd747 | 259 | This contains a pointer to the function jump table used. |
96aa2d94 RM |
260 | This is for compatibility with C++ streambuf; the word can |
261 | be used to smash to a pointer to a virtual function table. */ | |
262 | ||
263 | struct _IO_FILE_plus { | |
264 | _IO_FILE file; | |
96aa2d94 | 265 | const struct _IO_jump_t *vtable; |
96aa2d94 RM |
266 | }; |
267 | ||
268 | /* Generic functions */ | |
269 | ||
270 | extern _IO_fpos_t _IO_seekoff __P((_IO_FILE*, _IO_off_t, int, int)); | |
271 | extern _IO_fpos_t _IO_seekpos __P((_IO_FILE*, _IO_fpos_t, int)); | |
272 | ||
273 | extern int _IO_switch_to_get_mode __P((_IO_FILE*)); | |
274 | extern void _IO_init __P((_IO_FILE*, int)); | |
275 | extern int _IO_sputbackc __P((_IO_FILE*, int)); | |
276 | extern int _IO_sungetc __P((_IO_FILE*)); | |
277 | extern void _IO_un_link __P((_IO_FILE*)); | |
278 | extern void _IO_link_in __P((_IO_FILE *)); | |
279 | extern void _IO_doallocbuf __P((_IO_FILE*)); | |
280 | extern void _IO_unsave_markers __P((_IO_FILE*)); | |
281 | extern void _IO_setb __P((_IO_FILE*, char*, char*, int)); | |
282 | extern unsigned _IO_adjust_column __P((unsigned, const char *, int)); | |
283 | #define _IO_sputn(__fp, __s, __n) _IO_XSPUTN(__fp, __s, __n) | |
284 | ||
285 | /* Marker-related function. */ | |
286 | ||
287 | extern void _IO_init_marker __P((struct _IO_marker *, _IO_FILE *)); | |
288 | extern void _IO_remove_marker __P((struct _IO_marker*)); | |
289 | extern int _IO_marker_difference __P((struct _IO_marker *, struct _IO_marker *)); | |
290 | extern int _IO_marker_delta __P((struct _IO_marker *)); | |
291 | extern int _IO_seekmark __P((_IO_FILE *, struct _IO_marker *, int)); | |
292 | ||
293 | /* Default jumptable functions. */ | |
294 | ||
295 | extern int _IO_default_underflow __P((_IO_FILE*)); | |
296 | extern int _IO_default_uflow __P((_IO_FILE*)); | |
297 | extern int _IO_default_doallocate __P((_IO_FILE*)); | |
298 | extern void _IO_default_finish __P((_IO_FILE *)); | |
299 | extern int _IO_default_pbackfail __P((_IO_FILE*, int)); | |
300 | extern _IO_FILE* _IO_default_setbuf __P((_IO_FILE *, char*, _IO_ssize_t)); | |
301 | extern _IO_size_t _IO_default_xsputn __P((_IO_FILE *, const void*, _IO_size_t)); | |
302 | extern _IO_size_t _IO_default_xsgetn __P((_IO_FILE *, void*, _IO_size_t)); | |
303 | extern _IO_fpos_t _IO_default_seekoff __P((_IO_FILE*, _IO_off_t, int, int)); | |
304 | extern _IO_fpos_t _IO_default_seekpos __P((_IO_FILE*, _IO_fpos_t, int)); | |
305 | extern _IO_ssize_t _IO_default_write __P((_IO_FILE*,const void*,_IO_ssize_t)); | |
306 | extern _IO_ssize_t _IO_default_read __P((_IO_FILE*, void*, _IO_ssize_t)); | |
307 | extern int _IO_default_stat __P((_IO_FILE*, void*)); | |
308 | extern _IO_fpos_t _IO_default_seek __P((_IO_FILE*, _IO_off_t, int)); | |
309 | extern int _IO_default_sync __P((_IO_FILE*)); | |
310 | #define _IO_default_close ((_IO_close_t)_IO_default_sync) | |
311 | ||
312 | extern struct _IO_jump_t _IO_file_jumps; | |
313 | extern struct _IO_jump_t _IO_streambuf_jumps; | |
314 | extern struct _IO_jump_t _IO_proc_jumps; | |
315 | extern struct _IO_jump_t _IO_str_jumps; | |
316 | extern int _IO_do_write __P((_IO_FILE*, const char*, _IO_size_t)); | |
317 | extern int _IO_flush_all __P((void)); | |
318 | extern void _IO_cleanup __P((void)); | |
319 | extern void _IO_flush_all_linebuffered __P((void)); | |
320 | ||
321 | #define _IO_do_flush(_f) \ | |
322 | _IO_do_write(_f, (_f)->_IO_write_base, \ | |
323 | (_f)->_IO_write_ptr-(_f)->_IO_write_base) | |
324 | #define _IO_in_put_mode(_fp) ((_fp)->_flags & _IO_CURRENTLY_PUTTING) | |
325 | #define _IO_mask_flags(fp, f, mask) \ | |
326 | ((fp)->_flags = ((fp)->_flags & ~(mask)) | ((f) & (mask))) | |
327 | #define _IO_setg(fp, eb, g, eg) ((fp)->_IO_read_base = (eb),\ | |
328 | (fp)->_IO_read_ptr = (g), (fp)->_IO_read_end = (eg)) | |
329 | #define _IO_setp(__fp, __p, __ep) \ | |
330 | ((__fp)->_IO_write_base = (__fp)->_IO_write_ptr = __p, (__fp)->_IO_write_end = (__ep)) | |
331 | #define _IO_have_backup(fp) ((fp)->_IO_save_base != NULL) | |
332 | #define _IO_in_backup(fp) ((fp)->_flags & _IO_IN_BACKUP) | |
333 | #define _IO_have_markers(fp) ((fp)->_markers != NULL) | |
f65fd747 | 334 | #define _IO_blen(fp) ((fp)->_IO_buf_end - (fp)->_IO_buf_base) |
96aa2d94 RM |
335 | |
336 | /* Jumptable functions for files. */ | |
337 | ||
338 | extern int _IO_file_doallocate __P((_IO_FILE*)); | |
339 | extern _IO_FILE* _IO_file_setbuf __P((_IO_FILE *, char*, _IO_ssize_t)); | |
340 | extern _IO_fpos_t _IO_file_seekoff __P((_IO_FILE*, _IO_off_t, int, int)); | |
341 | extern _IO_size_t _IO_file_xsputn __P((_IO_FILE*,const void*,_IO_size_t)); | |
342 | extern int _IO_file_stat __P((_IO_FILE*, void*)); | |
343 | extern int _IO_file_close __P((_IO_FILE*)); | |
344 | extern int _IO_file_underflow __P((_IO_FILE *)); | |
345 | extern int _IO_file_overflow __P((_IO_FILE *, int)); | |
346 | #define _IO_file_is_open(__fp) ((__fp)->_fileno >= 0) | |
347 | extern void _IO_file_init __P((_IO_FILE*)); | |
348 | extern _IO_FILE* _IO_file_attach __P((_IO_FILE*, int)); | |
349 | extern _IO_FILE* _IO_file_fopen __P((_IO_FILE*, const char*, const char*)); | |
350 | extern _IO_ssize_t _IO_file_write __P((_IO_FILE*,const void*,_IO_ssize_t)); | |
351 | extern _IO_ssize_t _IO_file_read __P((_IO_FILE*, void*, _IO_ssize_t)); | |
352 | extern int _IO_file_sync __P((_IO_FILE*)); | |
353 | extern int _IO_file_close_it __P((_IO_FILE*)); | |
354 | extern _IO_fpos_t _IO_file_seek __P((_IO_FILE *, _IO_off_t, int)); | |
355 | extern void _IO_file_finish __P((_IO_FILE*)); | |
356 | ||
357 | /* Other file functions. */ | |
358 | extern _IO_FILE* _IO_file_attach __P((_IO_FILE *, int)); | |
359 | ||
360 | /* Jumptable functions for proc_files. */ | |
361 | extern _IO_FILE* _IO_proc_open __P((_IO_FILE*, const char*, const char *)); | |
362 | extern int _IO_proc_close __P((_IO_FILE*)); | |
363 | ||
364 | /* Jumptable functions for strfiles. */ | |
365 | extern int _IO_str_underflow __P((_IO_FILE*)); | |
366 | extern int _IO_str_overflow __P((_IO_FILE *, int)); | |
367 | extern int _IO_str_pbackfail __P((_IO_FILE*, int)); | |
368 | extern _IO_fpos_t _IO_str_seekoff __P((_IO_FILE*,_IO_off_t,int,int)); | |
369 | extern void _IO_str_finish __P ((_IO_FILE*)); | |
370 | ||
371 | /* Other strfile functions */ | |
372 | extern void _IO_str_init_static __P((_IO_FILE *, char*, int, char*)); | |
373 | extern void _IO_str_init_readonly __P((_IO_FILE *, const char*, int)); | |
374 | extern _IO_ssize_t _IO_str_count __P ((_IO_FILE*)); | |
375 | ||
fa0bc87c RM |
376 | extern int _IO_vasprintf __P ((char **result_ptr, __const char *format, |
377 | _IO_va_list args)); | |
378 | extern int _IO_vdprintf __P ((int d, __const char *format, _IO_va_list arg)); | |
379 | extern int _IO_vsnprintf __P ((char *string, _IO_size_t maxlen, | |
380 | __const char *format, _IO_va_list args)); | |
381 | ||
382 | ||
96aa2d94 RM |
383 | extern _IO_size_t _IO_getline __P((_IO_FILE*,char*,_IO_size_t,int,int)); |
384 | extern _IO_ssize_t _IO_getdelim __P((char**, _IO_size_t*, int, _IO_FILE*)); | |
385 | extern double _IO_strtod __P((const char *, char **)); | |
386 | extern char * _IO_dtoa __P((double __d, int __mode, int __ndigits, | |
387 | int *__decpt, int *__sign, char **__rve)); | |
388 | extern int _IO_outfloat __P((double __value, _IO_FILE *__sb, int __type, | |
389 | int __width, int __precision, int __flags, | |
390 | int __sign_mode, int __fill)); | |
391 | ||
392 | extern _IO_FILE *_IO_list_all; | |
393 | extern void (*_IO_cleanup_registration_needed) __P ((void)); | |
394 | ||
395 | #ifndef EOF | |
396 | #define EOF (-1) | |
397 | #endif | |
398 | #ifndef NULL | |
f8b87ef0 UD |
399 | #if defined __GNUG__ && \ |
400 | (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 8)) | |
f65fd747 UD |
401 | #define NULL (__null) |
402 | #else | |
403 | #if !defined(__cplusplus) | |
96aa2d94 RM |
404 | #define NULL ((void*)0) |
405 | #else | |
406 | #define NULL (0) | |
407 | #endif | |
408 | #endif | |
f65fd747 | 409 | #endif |
96aa2d94 | 410 | |
f8b87ef0 UD |
411 | #if _G_HAVE_MMAP |
412 | ||
413 | #include <unistd.h> | |
414 | #include <fcntl.h> | |
415 | #include <sys/mman.h> | |
416 | #include <sys/param.h> | |
417 | ||
418 | #if !defined(MAP_ANONYMOUS) && defined(MAP_ANON) | |
419 | #define MAP_ANONYMOUS MAP_ANON | |
420 | #endif | |
421 | ||
422 | #if !defined(MAP_ANONYMOUS) || !defined(EXEC_PAGESIZE) | |
423 | #undef _G_HAVE_MMAP | |
424 | #define _G_HAVE_MMAP 0 | |
425 | #endif | |
426 | ||
427 | #endif /* _G_HAVE_MMAP */ | |
428 | ||
429 | #if _G_HAVE_MMAP | |
430 | ||
10dc2a90 UD |
431 | #ifdef _LIBC |
432 | /* When using this code in the GNU libc we must not pollute the name space. */ | |
433 | #define mmap __mmap | |
434 | #define munmap __munmap | |
435 | #endif | |
436 | ||
f8b87ef0 UD |
437 | #define ROUND_TO_PAGE(_S) \ |
438 | (((_S) + EXEC_PAGESIZE - 1) & ~(EXEC_PAGESIZE - 1)) | |
439 | ||
440 | #define FREE_BUF(_B, _S) \ | |
441 | munmap ((_B), ROUND_TO_PAGE (_S)) | |
442 | #define ALLOC_BUF(_B, _S, _R) \ | |
443 | do { \ | |
444 | (_B) = (char *) mmap (0, ROUND_TO_PAGE (_S), \ | |
445 | PROT_READ | PROT_WRITE, \ | |
446 | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); \ | |
447 | if ((_B) == (char *) -1) \ | |
448 | return (_R); \ | |
449 | } while (0) | |
450 | ||
451 | #else /* _G_HAVE_MMAP */ | |
452 | ||
453 | #define FREE_BUF(_B, _S) \ | |
454 | free(_B) | |
455 | #define ALLOC_BUF(_B, _S, _R) \ | |
456 | do { \ | |
457 | (_B) = (char*)malloc(_S); \ | |
458 | if ((_B) == NULL) \ | |
459 | return (_R); \ | |
460 | } while (0) | |
461 | ||
462 | #endif /* _G_HAVE_MMAP */ | |
96aa2d94 RM |
463 | |
464 | #ifndef OS_FSTAT | |
465 | #define OS_FSTAT fstat | |
466 | #endif | |
467 | struct stat; | |
468 | extern _IO_ssize_t _IO_read __P((int, void*, _IO_size_t)); | |
469 | extern _IO_ssize_t _IO_write __P((int, const void*, _IO_size_t)); | |
470 | extern _IO_off_t _IO_lseek __P((int, _IO_off_t, int)); | |
471 | extern int _IO_close __P((int)); | |
472 | extern int _IO_fstat __P((int, struct stat *)); | |
7f811679 | 473 | extern int _IO_vscanf __P((const char *, _IO_va_list)); |
96aa2d94 RM |
474 | |
475 | /* Operations on _IO_fpos_t. | |
476 | Normally, these are trivial, but we provide hooks for configurations | |
477 | where an _IO_fpos_t is a struct. | |
478 | Note that _IO_off_t must be an integral type. */ | |
479 | ||
480 | /* _IO_pos_BAD is an _IO_fpos_t value indicating error, unknown, or EOF. */ | |
481 | #ifndef _IO_pos_BAD | |
482 | #define _IO_pos_BAD ((_IO_fpos_t)(-1)) | |
483 | #endif | |
484 | /* _IO_pos_as_off converts an _IO_fpos_t value to an _IO_off_t value. */ | |
485 | #ifndef _IO_pos_as_off | |
486 | #define _IO_pos_as_off(__pos) ((_IO_off_t)(__pos)) | |
487 | #endif | |
488 | /* _IO_pos_adjust adjust an _IO_fpos_t by some number of bytes. */ | |
489 | #ifndef _IO_pos_adjust | |
490 | #define _IO_pos_adjust(__pos, __delta) ((__pos) += (__delta)) | |
491 | #endif | |
492 | /* _IO_pos_0 is an _IO_fpos_t value indicating beginning of file. */ | |
493 | #ifndef _IO_pos_0 | |
494 | #define _IO_pos_0 ((_IO_fpos_t)0) | |
495 | #endif | |
496 | ||
497 | #ifdef __cplusplus | |
498 | } | |
499 | #endif | |
500 | ||
499e7464 | 501 | #ifdef _IO_MTSAFE_IO |
96aa2d94 RM |
502 | /* check following! */ |
503 | #define FILEBUF_LITERAL(CHAIN, FLAGS, FD) \ | |
504 | { _IO_MAGIC+_IO_LINKED+_IO_IS_FILEBUF+FLAGS, \ | |
f65fd747 | 505 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, CHAIN, FD, \ |
499e7464 UD |
506 | 0, 0, 0, 0, { 0 }, &_IO_stdfile_##FD##_lock } |
507 | #else | |
508 | /* check following! */ | |
509 | #define FILEBUF_LITERAL(CHAIN, FLAGS, FD) \ | |
510 | { _IO_MAGIC+_IO_LINKED+_IO_IS_FILEBUF+FLAGS, \ | |
f65fd747 | 511 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, CHAIN, FD } |
499e7464 | 512 | #endif |
96aa2d94 RM |
513 | |
514 | /* VTABLE_LABEL defines NAME as of the CLASS class. | |
515 | CNLENGTH is strlen(#CLASS). */ | |
516 | #ifdef __GNUC__ | |
517 | #if _G_VTABLE_LABEL_HAS_LENGTH | |
518 | #define VTABLE_LABEL(NAME, CLASS, CNLENGTH) \ | |
519 | extern char NAME[] asm (_G_VTABLE_LABEL_PREFIX #CNLENGTH #CLASS); | |
520 | #else | |
521 | #define VTABLE_LABEL(NAME, CLASS, CNLENGTH) \ | |
522 | extern char NAME[] asm (_G_VTABLE_LABEL_PREFIX #CLASS); | |
523 | #endif | |
524 | #endif /* __GNUC__ */ | |
525 | ||
526 | #if !defined(builtinbuf_vtable) && defined(__cplusplus) | |
527 | #ifdef __GNUC__ | |
528 | VTABLE_LABEL(builtinbuf_vtable, builtinbuf, 10) | |
529 | #else | |
530 | #if _G_VTABLE_LABEL_HAS_LENGTH | |
531 | #define builtinbuf_vtable _G_VTABLE_LABEL_PREFIX_ID##10builtinbuf | |
532 | #else | |
533 | #define builtinbuf_vtable _G_VTABLE_LABEL_PREFIX_ID##builtinbuf | |
534 | #endif | |
535 | #endif | |
536 | #endif /* !defined(builtinbuf_vtable) && defined(__cplusplus) */ | |
537 | ||
538 | #if defined(__STDC__) || defined(__cplusplus) | |
539 | #define _IO_va_start(args, last) va_start(args, last) | |
540 | #else | |
541 | #define _IO_va_start(args, last) va_start(args) | |
542 | #endif | |
543 | ||
544 | extern struct _IO_fake_stdiobuf _IO_stdin_buf, _IO_stdout_buf, _IO_stderr_buf; | |
545 | ||
546 | #if 1 | |
547 | #define COERCE_FILE(FILE) /* Nothing */ | |
548 | #else | |
549 | /* This is part of the kludge for binary compatibility with old stdio. */ | |
550 | #define COERCE_FILE(FILE) \ | |
551 | (((FILE)->_IO_file_flags & _IO_MAGIC_MASK) == _OLD_MAGIC_MASK \ | |
552 | && (FILE) = *(FILE**)&((int*)fp)[1]) | |
553 | #endif | |
554 | ||
555 | #ifdef EINVAL | |
c4029823 | 556 | #define MAYBE_SET_EINVAL __set_errno (EINVAL) |
96aa2d94 RM |
557 | #else |
558 | #define MAYBE_SET_EINVAL /* nothing */ | |
559 | #endif | |
560 | ||
f65fd747 | 561 | #ifdef IO_DEBUG |
96aa2d94 RM |
562 | #define CHECK_FILE(FILE,RET) \ |
563 | if ((FILE) == NULL) { MAYBE_SET_EINVAL; return RET; } \ | |
564 | else { COERCE_FILE(FILE); \ | |
565 | if (((FILE)->_IO_file_flags & _IO_MAGIC_MASK) != _IO_MAGIC) \ | |
68dbb3a6 | 566 | { MAYBE_SET_EINVAL; return RET; }} |
96aa2d94 RM |
567 | #else |
568 | #define CHECK_FILE(FILE,RET) \ | |
569 | COERCE_FILE(FILE) | |
570 | #endif |