1 /*
2 * Copyright (c) 1999
3 * Silicon Graphics Computer Systems, Inc.
4 *
5 * Copyright (c) 1999
6 * Boris Fomitchev
7 *
8 * This material is provided "as is", with absolutely no warranty expressed
9 * or implied. Any use is at your own risk.
10 *
11 * Permission to use or copy this software for any purpose is hereby granted
12 * without fee, provided the above notices are retained on all copies.
13 * Permission to modify the code and to distribute modified code is granted,
14 * provided the above notices are retained, and a notice that the code was
15 * modified is included with the above copyright notice.
16 *
17 */
18
19
20 // WARNING: This is an internal header file, included by other C++
21 // standard library headers. You should not attempt to use this header
22 // file directly.
23
24
25 #ifndef _STLP_STDIO_FILE_H
26 #define _STLP_STDIO_FILE_H
27
28 // This file provides a low-level interface between the internal
29 // representation of struct FILE, from the C stdio library, and
30 // the C++ I/O library. The C++ I/O library views a FILE object as
31 // a collection of three pointers: the beginning of the buffer, the
32 // current read/write position, and the end of the buffer.
33
34 // The interface:
35 // - char* _FILE_[IO]_begin(const FILE *__f);
36 // Returns a pointer to the beginning of the buffer.
37 // - char* _FILE_[IO]_next(const FILE *__f);
38 // Returns the current read/write position within the buffer.
39 // - char* _FILE_[IO]_end(const FILE *__f);
40 // Returns a pointer immediately past the end of the buffer.
41 // - char* _FILE_[IO]_avail(const FILE *__f);
42 // Returns the number of characters remaining in the buffer, i.e.
43 // _FILE_[IO]_end(__f) - _FILE_[IO]_next(__f).
44 // - char& _FILE_[IO]_preincr(FILE *__f)
45 // Increments the current read/write position by 1, returning the
46 // character at the old position.
47 // - char& _FILE_[IO]_postincr(FILE *__f)
48 // Increments the current read/write position by 1, returning the
49 // character at the old position.
50 // - char& _FILE_[IO]_predecr(FILE *__f)
51 // Decrements the current read/write position by 1, returning the
52 // character at the old position.
53 // - char& _FILE_[IO]_postdecr(FILE *__f)
54 // Decrements the current read/write position by 1, returning the
55 // character at the old position.
56 // - void _FILE_[IO]_bump(FILE *__f, int __n)
57 // Increments the current read/write position by __n.
58 // - void _FILE_[IO]_set(FILE *__f, char* __begin, char* __next, char* __end);
59 // Sets the beginning of the bufer to __begin, the current read/write
60 // position to __next, and the buffer's past-the-end pointer to __end.
61 // If any of those pointers is null, then all of them must be null.
62
63 // Each function comes in two versions, one for a FILE used as an input
64 // buffer and one for a FILE used as an output buffer. In some stdio
65 // implementations the two functions are identical, but in others they are
66 // not.
67
68 #ifndef _STLP_CSTDIO
69 # include <cstdio>
70 #endif
71 #ifndef _STLP_CSTDDEF
72 # include <cstddef>
73 #endif
74
75 #if defined(__MSL__) && !defined(N_PLAT_NLM)
76 # include <unix.h> // get the definition of fileno
77 #endif
78
79 _STLP_BEGIN_NAMESPACE
80
81 //----------------------------------------------------------------------
82 // Implementation for eMbedded Visual C++ 3.0 and 4.2 (.NET)
83 #if defined (_STLP_WCE)
84
_FILE_fd(const FILE * __f)85 inline int _FILE_fd(const FILE *__f)
86 {
87 /* check if FILE is one of the three standard streams
88 We do this check first, because invoking _fileno() on one of them
89 causes a terminal window to be created. This also happens if you do
90 any IO on them, but merely retrieving the filedescriptor shouldn't
91 already do that.
92
93 Obviously this is pretty implementation-specific because it requires
94 that indeed the first three FDs are always the same, but that is not
95 only common but almost guaranteed. */
96 for( int __fd=0; __fd!=3; ++__fd)
97 {
98 if(__f == _getstdfilex(__fd))
99 return __fd;
100 }
101
102 return (int)::_fileno((FILE*)__f);
103 }
104
105 # undef _STLP_FILE_I_O_IDENTICAL
106
107 // Implementation for the IRIX C library.
108 // Solaris interface looks to be identical.
109 #elif !defined(_STLP_USE_GLIBC) && \
110 ( defined(__sgi) || \
111 ( defined(__sun) && ! defined (_LP64) ) || \
112 defined (__osf__) || defined(__DECCXX) || \
113 (defined (_STLP_MSVC) && !defined (_STLP_WCE_EVC3)) || \
114 defined (__ICL) || defined (__MINGW32__) || defined(__DJGPP) || defined (_AIX) || defined (_CRAY))
115
116 #if defined (_STLP_MSVC) || defined (__ICL) || defined (__MINGW32__) || defined(__DJGPP)
117 typedef char* _File_ptr_type;
118 #else
119 typedef unsigned char* _File_ptr_type;
120 #endif
121
122 inline int _FILE_fd(const FILE *__f) { return __f->_file; }
123 inline char* _FILE_I_begin(const FILE *__f) { return (char*) __f->_base; }
124 inline char* _FILE_I_next(const FILE *__f) { return (char*) __f->_ptr; }
125 inline char* _FILE_I_end(const FILE *__f)
126 { return (char*) __f->_ptr + __f->_cnt; }
127
128 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->_cnt; }
129
130 inline char& _FILE_I_preincr(FILE *__f)
131 { --__f->_cnt; return *(char*) (++__f->_ptr); }
132 inline char& _FILE_I_postincr(FILE *__f)
133 { --__f->_cnt; return *(char*) (__f->_ptr++); }
134 inline char& _FILE_I_predecr(FILE *__f)
135 { ++__f->_cnt; return *(char*) (--__f->_ptr); }
136 inline char& _FILE_I_postdecr(FILE *__f)
137 { ++__f->_cnt; return *(char*) (__f->_ptr--); }
138 inline void _FILE_I_bump(FILE *__f, int __n)
139 { __f->_ptr += __n; __f->_cnt -= __n; }
140
141 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
142 __f->_base = (_File_ptr_type) __begin;
143 __f->_ptr = (_File_ptr_type) __next;
144 __f->_cnt = __end - __next;
145 }
146
147 # define _STLP_FILE_I_O_IDENTICAL 1
148
149 #elif defined(__EMX__)
150
151 inline int _FILE_fd(const FILE* __f) { return __f->_handle; }
152 inline char* _FILE_I_begin(const FILE* __f) { return (char*) __f->_buffer; }
153 inline char* _FILE_I_next(const FILE* __f) { return (char*) __f->_ptr; }
154 inline char* _FILE_I_end(const FILE* __f) { return (char *) __f->_ptr + __f->_rcount; }
155 inline ptrdiff_t _FILE_I_avail(const FILE* __f) { return __f->_rcount; }
156 inline char& _FILE_I_preincr(FILE* __f) { --__f->_rcount; return *(char*) (++__f->_ptr); }
157 inline char& _FILE_I_postincr(FILE* __f) { --__f->_rcount; return *(char*) (__f->_ptr++); }
158 inline char& _FILE_I_predecr(FILE* __f) { ++__f->_rcount; return *(char*) (--__f->_ptr); }
159 inline char& _FILE_I_postdecr(FILE* __f) { ++__f->_rcount; return *(char*) (__f->_ptr--); }
160 inline void _FILE_I_bump(FILE* __f, int __n) { __f->_ptr += __n; __f->_rcount -= __n; }
161 inline void _FILE_I_set(FILE* __f, char* __begin, char* __next, char* __end) {
162 __f->_buffer = __begin;
163 __f->_ptr = __next;
164 __f->_rcount = __end - __next;
165 }
166
167 inline char* _FILE_O_begin(const FILE* __f) { return (char*) __f->_buffer; }
168 inline char* _FILE_O_next(const FILE* __f) { return (char*) __f->_ptr; }
169 inline char* _FILE_O_end(const FILE* __f) { return (char*) __f->_ptr + __f->_wcount; }
170 inline ptrdiff_t _FILE_O_avail(const FILE* __f) { return __f->_wcount; }
171 inline char& _FILE_O_preincr(FILE* __f) { --__f->_wcount; return *(char*) (++__f->_ptr); }
172 inline char& _FILE_O_postincr(FILE* __f) { --__f->_wcount; return *(char*) (__f->_ptr++); }
173 inline char& _FILE_O_predecr(FILE* __f) { ++__f->_wcount; return *(char*) (--__f->_ptr); }
174 inline char& _FILE_O_postdecr(FILE* __f) { ++__f->_wcount; return *(char*) (__f->_ptr--); }
175 inline void _FILE_O_bump(FILE* __f, int __n) { __f->_ptr += __n; __f->_wcount -= __n; }
176 inline void _FILE_O_set(FILE* __f, char* __begin, char* __next, char* __end) {
177 __f->_buffer = __begin;
178 __f->_ptr = __next;
179 __f->_wcount = __end - __next;
180 }
181
182
183 # undef _STLP_FILE_I_O_IDENTICAL
184
185 # elif defined(_STLP_SCO_OPENSERVER) || defined(__NCR_SVR)
186
187 typedef unsigned char* _File_ptr_type;
188
189 inline int _FILE_fd(const FILE *__f) { return __f->__file; }
190 inline char* _FILE_I_begin(const FILE *__f) { return (char*) __f->__base; }
191 inline char* _FILE_I_next(const FILE *__f) { return (char*) __f->__ptr; }
192 inline char* _FILE_I_end(const FILE *__f)
193 { return (char*) __f->__ptr + __f->__cnt; }
194
195 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->__cnt; }
196
197 inline char& _FILE_I_preincr(FILE *__f)
198 { --__f->__cnt; return *(char*) (++__f->__ptr); }
199 inline char& _FILE_I_postincr(FILE *__f)
200 { --__f->__cnt; return *(char*) (__f->__ptr++); }
201 inline char& _FILE_I_predecr(FILE *__f)
202 { ++__f->__cnt; return *(char*) (--__f->__ptr); }
203 inline char& _FILE_I_postdecr(FILE *__f)
204 { ++__f->__cnt; return *(char*) (__f->__ptr--); }
205 inline void _FILE_I_bump(FILE *__f, int __n)
206 { __f->__ptr += __n; __f->__cnt -= __n; }
207
208 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
209 __f->__base = (_File_ptr_type) __begin;
210 __f->__ptr = (_File_ptr_type) __next;
211 __f->__cnt = __end - __next;
212 }
213
214 # define _STLP_FILE_I_O_IDENTICAL 1
215
216 # elif defined(__sun) && defined( _LP64)
217
218 typedef long _File_ptr_type;
219
220 inline int _FILE_fd(const FILE *__f) { return (int) __f->__pad[2]; }
221 inline char* _FILE_I_begin(const FILE *__f) { return (char*)
222 __f->__pad[1]; }
223 inline char* _FILE_I_next(const FILE *__f) { return (char*)
224 __f->__pad[0]; }
225 inline char* _FILE_I_end(const FILE *__f)
226 { return (char*) __f->__pad[0] + __f->__pad[3]; }
227
228 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->__pad[3]; }
229
230 inline char& _FILE_I_preincr(FILE *__f)
231 { --__f->__pad[3]; return *(char*) (++__f->__pad[0]); }
232 inline char& _FILE_I_postincr(FILE *__f)
233 { --__f->__pad[3]; return *(char*) (__f->__pad[0]++); }
234 inline char& _FILE_I_predecr(FILE *__f)
235 { ++__f->__pad[3]; return *(char*) (--__f->__pad[0]); }
236 inline char& _FILE_I_postdecr(FILE *__f)
237 { ++__f->__pad[3]; return *(char*) (__f->__pad[0]--); }
238 inline void _FILE_I_bump(FILE *__f, long __n)
239 { __f->__pad[0] += __n; __f->__pad[3] -= __n; }
240
241 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char*
242 __end) {
243 __f->__pad[1] = (_File_ptr_type) __begin;
244 __f->__pad[0] = (_File_ptr_type) __next;
245 __f->__pad[3] = __end - __next;
246 }
247
248 # define _STLP_FILE_I_O_IDENTICAL
249
250 #elif defined (__PIPS__)
251
252 inline int _FILE_fd(const FILE *__f) { return __f->_file; }
253 inline char* _FILE_I_begin(const FILE *__f) { return (char*) __f->_bf._base; }
254 inline char* _FILE_I_next(const FILE *__f) { return (char*) __f->_p; }
255 inline char* _FILE_I_end(const FILE *__f) { return (char*) __f->_p + __f->_r; }
256
257 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->_r; }
258
259 inline char& _FILE_I_preincr(FILE *__f)
260 { --__f->_r; --__f->_bf._size; return *(char*) (++__f->_p); }
261 inline char& _FILE_I_postincr(FILE *__f)
262 { --__f->_r; --__f->_bf._size; return *(char*) (__f->_p++); }
263 inline char& _FILE_I_predecr(FILE *__f)
264 { ++__f->_r; ++ __f->_bf._size; return *(char*) (--__f->_p); }
265 inline char& _FILE_I_postdecr(FILE *__f)
266 { ++__f->_r; ++__f->_bf._size; return *(char*) (__f->_p--); }
267 inline void _FILE_I_bump(FILE *__f, int __n)
268 { __f->_p += __n; __f->_bf._size+=__n; __f->_r -= __n; }
269
270 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
271 __f->_bf._base = (unsigned char*) __begin;
272 __f->_p = (unsigned char*) __next;
273 __f->_r = __f->_bf._size = __end - __next;
274 }
275 inline char* _FILE_O_begin(const FILE *__f) { return (char*) __f->_bf._base; }
276 inline char* _FILE_O_next(const FILE *__f) { return (char*) __f->_p; }
277 inline char* _FILE_O_end(const FILE *__f)
278 { return (char*) __f->_p + __f->_w; }
279
280 inline ptrdiff_t _FILE_O_avail(const FILE *__f) { return __f->_w; }
281
282 inline char& _FILE_O_preincr(FILE *__f)
283 { --__f->_w; --__f->_bf._size; return *(char*) (++__f->_p); }
284 inline char& _FILE_O_postincr(FILE *__f)
285 { --__f->_w; --__f->_bf._size; return *(char*) (__f->_p++); }
286 inline char& _FILE_O_predecr(FILE *__f)
287 { ++__f->_w; ++__f->_bf._size; return *(char*) (--__f->_p); }
288 inline char& _FILE_O_postdecr(FILE *__f)
289 { ++__f->_w; ++__f->_bf._size; return *(char*) (__f->_p--); }
290 inline void _FILE_O_bump(FILE *__f, int __n)
291 { __f->_p += __n; __f->_bf._size+=__n; __f->_w -= __n; }
292
293 inline void _FILE_O_set(FILE *__f, char* __begin, char* __next, char* __end) {
294 __f->_bf._base = (unsigned char*) __begin;
295 __f->_p = (unsigned char*) __next;
296 __f->_w = __f->_bf._size = __end - __next;
297 }
298
299 # undef _STLP_FILE_I_O_IDENTICAL
300
301 #elif defined (__CYGWIN__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) \
302 || defined(__amigaos__) || ( defined(__GNUC__) && defined(__APPLE__) )
303
304 inline int _FILE_fd(const FILE *__f) { return __f->_file; }
305 inline char* _FILE_I_begin(const FILE *__f) { return (char*) __f->_bf._base; }
306 inline char* _FILE_I_next(const FILE *__f) { return (char*) __f->_p; }
307 inline char* _FILE_I_end(const FILE *__f)
308 { return (char*) __f->_p + __f->_r; }
309
310 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->_r; }
311
312 #if ( defined(__GNUC__) && defined(__APPLE__) )
313 inline char& _FILE_I_preincr(FILE *__f)
314 { --__f->_r; return *(char*) (++__f->_p); }
315 inline char& _FILE_I_postincr(FILE *__f)
316 { --__f->_r; return *(char*) (__f->_p++); }
317 inline char& _FILE_I_predecr(FILE *__f)
318 { ++__f->_r; return *(char*) (--__f->_p); }
319 inline char& _FILE_I_postdecr(FILE *__f)
320 { ++__f->_r; return *(char*) (__f->_p--); }
321 inline void _FILE_I_bump(FILE *__f, int __n)
322 { __f->_p += __n; __f->_r -= __n; }
323 #else
324 inline char& _FILE_I_preincr(FILE *__f)
325 { --__f->_r; --__f->_bf._size; return *(char*) (++__f->_p); }
326 inline char& _FILE_I_postincr(FILE *__f)
327 { --__f->_r; --__f->_bf._size; return *(char*) (__f->_p++); }
328 inline char& _FILE_I_predecr(FILE *__f)
329 { ++__f->_r; ++ __f->_bf._size; return *(char*) (--__f->_p); }
330 inline char& _FILE_I_postdecr(FILE *__f)
331 { ++__f->_r; ++__f->_bf._size; return *(char*) (__f->_p--); }
332 inline void _FILE_I_bump(FILE *__f, int __n)
333 { __f->_p += __n; __f->_bf._size+=__n; __f->_r -= __n; }
334 #endif
335
336 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
337 __f->_bf._base = (unsigned char*) __begin;
338 __f->_p = (unsigned char*) __next;
339 __f->_r = __f->_bf._size = __end - __next;
340 }
341 inline char* _FILE_O_begin(const FILE *__f) { return (char*) __f->_bf._base; }
342 inline char* _FILE_O_next(const FILE *__f) { return (char*) __f->_p; }
343 inline char* _FILE_O_end(const FILE *__f)
344 { return (char*) __f->_p + __f->_w; }
345
346 inline ptrdiff_t _FILE_O_avail(const FILE *__f) { return __f->_w; }
347
348 #if ( defined(__GNUC__) && defined(__APPLE__) )
349 inline char& _FILE_O_preincr(FILE *__f)
350 { --__f->_w; return *(char*) (++__f->_p); }
351 inline char& _FILE_O_postincr(FILE *__f)
352 { --__f->_w; return *(char*) (__f->_p++); }
353 inline char& _FILE_O_predecr(FILE *__f)
354 { ++__f->_w; return *(char*) (--__f->_p); }
355 inline char& _FILE_O_postdecr(FILE *__f)
356 { ++__f->_w; return *(char*) (__f->_p--); }
357 inline void _FILE_O_bump(FILE *__f, int __n)
358 { __f->_p += __n; __f->_w -= __n; }
359 #else
360 inline char& _FILE_O_preincr(FILE *__f)
361 { --__f->_w; --__f->_bf._size; return *(char*) (++__f->_p); }
362 inline char& _FILE_O_postincr(FILE *__f)
363 { --__f->_w; --__f->_bf._size; return *(char*) (__f->_p++); }
364 inline char& _FILE_O_predecr(FILE *__f)
365 { ++__f->_w; ++__f->_bf._size; return *(char*) (--__f->_p); }
366 inline char& _FILE_O_postdecr(FILE *__f)
367 { ++__f->_w; ++__f->_bf._size; return *(char*) (__f->_p--); }
368 inline void _FILE_O_bump(FILE *__f, int __n)
369 { __f->_p += __n; __f->_bf._size+=__n; __f->_w -= __n; }
370 #endif
371
372 inline void _FILE_O_set(FILE *__f, char* __begin, char* __next, char* __end) {
373 __f->_bf._base = (unsigned char*) __begin;
374 __f->_p = (unsigned char*) __next;
375 __f->_w = __f->_bf._size = __end - __next;
376 }
377
378 # undef _STLP_FILE_I_O_IDENTICAL
379
380 #elif defined(_STLP_USE_UCLIBC) /* should be before _STLP_USE_GLIBC */
381 inline int _FILE_fd(const FILE *__f) { return fileno(__CONST_CAST(FILE *,__f)); }
382 #elif defined(_STLP_USE_GLIBC)
383
384 inline int _FILE_fd(const FILE *__f) { return __f->_fileno; }
385 inline char* _FILE_I_begin(const FILE *__f) { return __f->_IO_read_base; }
386 inline char* _FILE_I_next(const FILE *__f) { return __f->_IO_read_ptr; }
387 inline char* _FILE_I_end(const FILE *__f) { return __f->_IO_read_end; }
388
389 inline ptrdiff_t _FILE_I_avail(const FILE *__f)
390 { return __f->_IO_read_end - __f->_IO_read_ptr; }
391
392 inline char& _FILE_I_preincr(FILE *__f) { return *++__f->_IO_read_ptr; }
393 inline char& _FILE_I_postincr(FILE *__f) { return *__f->_IO_read_ptr++; }
394 inline char& _FILE_I_predecr(FILE *__f) { return *--__f->_IO_read_ptr; }
395 inline char& _FILE_I_postdecr(FILE *__f) { return *__f->_IO_read_ptr--; }
396 inline void _FILE_I_bump(FILE *__f, int __n) { __f->_IO_read_ptr += __n; }
397
398 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
399 __f->_IO_read_base = __begin;
400 __f->_IO_read_ptr = __next;
401 __f->_IO_read_end = __end;
402 }
403
404 inline char* _FILE_O_begin(const FILE *__f) { return __f->_IO_write_base; }
405 inline char* _FILE_O_next(const FILE *__f) { return __f->_IO_write_ptr; }
406 inline char* _FILE_O_end(const FILE *__f) { return __f->_IO_write_end; }
407
408 inline ptrdiff_t _FILE_O_avail(const FILE *__f)
409 { return __f->_IO_write_end - __f->_IO_write_ptr; }
410
411 inline char& _FILE_O_preincr(FILE *__f) { return *++__f->_IO_write_ptr; }
412 inline char& _FILE_O_postincr(FILE *__f) { return *__f->_IO_write_ptr++; }
413 inline char& _FILE_O_predecr(FILE *__f) { return *--__f->_IO_write_ptr; }
414 inline char& _FILE_O_postdecr(FILE *__f) { return *__f->_IO_write_ptr--; }
415 inline void _FILE_O_bump(FILE *__f, int __n) { __f->_IO_write_ptr += __n; }
416
417 inline void _FILE_O_set(FILE *__f, char* __begin, char* __next, char* __end) {
418 __f->_IO_write_base = __begin;
419 __f->_IO_write_ptr = __next;
420 __f->_IO_write_end = __end;
421
422 }
423
424 #elif defined(__hpux) /* && defined(__hppa) && defined(__HP_aCC)) */
425
426 #ifndef _INCLUDE_HPUX_SOURCE
427 extern "C" unsigned char *__bufendtab[];
428 # undef _bufend
429 # define _bufend(__p) \
430 (*(((__p)->__flag & _IOEXT) ? &(((_FILEX *)(__p))->__bufendp) \
431 : &(__bufendtab[(__p) - __iob])))
432
433 # define _bufsiz(__p) (_bufend(__p) - (__p)->__base)
434 #endif /* _INCLUDE_HPUX_SOURCE */
435
436 #if defined(_STLP_HPACC_BROKEN_BUFEND)
437 # undef _bufend
438 # define _bufend(__p) \
439 (*(((__p)->__flag & _IOEXT) ? &((__REINTERPRET_CAST(_FILEX*,(__p)))->__bufendp) \
440 : &(__bufendtab[__REINTERPRET_CAST(FILE*,(__p)) - __iob])))
441 #endif
442
443 inline int _FILE_fd(const FILE *__f) { return fileno(__CONST_CAST(FILE *,__f)); }
444 inline char* _FILE_I_begin(const FILE *__f) { return (__REINTERPRET_CAST(char*, __f->__base)); }
445 inline char* _FILE_I_next(const FILE *__f) { return (__REINTERPRET_CAST(char*, __f->__ptr)); }
446 inline char* _FILE_I_end(const FILE *__f) { return (__REINTERPRET_CAST(char*, __f->__ptr +__f->__cnt)); }
447
448 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->__cnt; }
449
450 inline char& _FILE_I_preincr(FILE *__f) { --__f->__cnt; return *__REINTERPRET_CAST(char*, ++__f->__ptr); }
451 inline char& _FILE_I_postincr(FILE *__f) { --__f->__cnt; return *__REINTERPRET_CAST(char*, __f->__ptr++); }
452 inline char& _FILE_I_predecr(FILE *__f) { ++__f->__cnt; return *__REINTERPRET_CAST(char*,--__f->__ptr); }
453 inline char& _FILE_I_postdecr(FILE *__f) { ++__f->__cnt; return *__REINTERPRET_CAST(char*,__f->__ptr--); }
454 inline void _FILE_I_bump(FILE *__f, int __n) { __f->__cnt -= __n; __f->__ptr += __n; }
455
456 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
457 # if defined(__hpux)
458 if( (unsigned long) (__f - &__iob[0]) > _NFILE)
459 __f->__flag |= _IOEXT; // used by stdio's _bufend macro and goodness knows what else...
460 # endif
461 __f->__cnt = __end - __next;
462 __f->__base = __REINTERPRET_CAST(unsigned char*, __begin);
463 __f->__ptr = __REINTERPRET_CAST(unsigned char*, __next);
464 _bufend(__f) = __REINTERPRET_CAST(unsigned char*, __end);
465 }
466
467 // For HPUX stdio, input and output FILE manipulation is identical.
468
469 # define _STLP_FILE_I_O_IDENTICAL
470
471 #elif defined (__BORLANDC__)
472
473 typedef unsigned char* _File_ptr_type;
474
475 inline int _FILE_fd(const FILE *__f) { return __f->fd; }
476 inline char* _FILE_I_begin(const FILE *__f) { return (char*) __f->buffer;
477 }
478 inline char* _FILE_I_next(const FILE *__f)
479 { return (char*)__f->curp; }
480 inline char* _FILE_I_end(const FILE *__f)
481 { return (char*) __f->curp + __f->level; }
482
483 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->level; }
484
485 inline char& _FILE_I_preincr(FILE *__f)
486 { --__f->level; return *(char*) (++__f->curp); }
487 inline char& _FILE_I_postincr(FILE *__f)
488 { --__f->level; return *(char*) (__f->curp++); }
489 inline char& _FILE_I_predecr(FILE *__f)
490 { ++__f->level; return *(char*) (--__f->curp); }
491 inline char& _FILE_I_postdecr(FILE *__f)
492 { ++__f->level; return *(char*) (__f->curp--); }
493 inline void _FILE_I_bump(FILE *__f, int __n)
494 { __f->curp += __n; __f->level -= __n; }
495
496 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
497 __f->buffer = (_File_ptr_type) __begin;
498 __f->curp = (_File_ptr_type) __next;
499 __f->level = __end - __next;
500 }
501
502 # define _STLP_FILE_I_O_IDENTICAL
503
504 #elif defined( __MWERKS__ )
505
506 // using MWERKS-specific defines here to detect other OS targets
507 // dwa: I'm not sure they provide fileno for all OS's, but this should
508 // work for Win32 and WinCE
509
510 #ifndef N_PLAT_NLM
511 // Hmm, at least for Novell NetWare __dest_os == __mac_os true too..
512 // May be both __dest_os and __mac_os defined and empty? - ptr
513 # if __dest_os == __mac_os
514 inline int _FILE_fd(const FILE *__f) { return ::fileno(__CONST_CAST(FILE*, __f)); }
515 # else
516 inline int _FILE_fd(const FILE *__f) { return ::_fileno(__CONST_CAST(FILE*, __f)); }
517 # endif // __dest_os == __mac_os
518
519 // Returns a pointer to the beginning of the buffer.
520 inline char* _FILE_I_begin(const FILE *__f) { return __REINTERPRET_CAST(char*, __f->buffer); }
521 // Returns the current read/write position within the buffer.
522 inline char* _FILE_I_next(const FILE *__f) { return __REINTERPRET_CAST(char*, __f->buffer_ptr); }
523
524 // Returns a pointer immediately past the end of the buffer.
525 inline char* _FILE_I_end(const FILE *__f) { return __REINTERPRET_CAST(char*, __f->buffer_ptr + __f->buffer_len); }
526
527 // Returns the number of characters remaining in the buffer, i.e.
528 // _FILE_[IO]_end(__f) - _FILE_[IO]_next(__f).
529 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->buffer_len; }
530
531 // Increments the current read/write position by 1, returning the
532 // character at the old position.
533 inline char& _FILE_I_preincr(FILE *__f)
534 { --__f->buffer_len; return *(char*) (++__f->buffer_ptr); }
535 inline char& _FILE_I_postincr(FILE *__f)
536 { --__f->buffer_len; return *(char*) (__f->buffer_ptr++); }
537 inline char& _FILE_I_predecr(FILE *__f)
538 { ++__f->buffer_len; return *(char*) (--__f->buffer_ptr); }
539 inline char& _FILE_I_postdecr(FILE *__f)
540 { ++__f->buffer_len; return *(char*) (__f->buffer_ptr--); }
541 inline void _FILE_I_bump(FILE *__f, int __n)
542 { __f->buffer_ptr += __n; __f->buffer_len -= __n; }
543
544 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
545 __f->buffer = __REINTERPRET_CAST(unsigned char*, __begin);
546 __f->buffer_ptr = __REINTERPRET_CAST(unsigned char*, __next);
547 __f->buffer_len = __end - __next;
548 __f->buffer_size = __end - __begin;
549 }
550 #else // N_PLAT_NLM - ptr
551 inline int _FILE_fd(const FILE *__f) { return __f->_file; }
552 inline char* _FILE_I_begin(const FILE *__f) { return __REINTERPRET_CAST(char*, __f->_base); }
553 // Returns the current read/write position within the buffer.
554 inline char* _FILE_I_next(const FILE *__f) { return __REINTERPRET_CAST(char*, __f->_ptr); }
555
556 // Returns a pointer immediately past the end of the buffer.
557 inline char* _FILE_I_end(const FILE *__f) { return __REINTERPRET_CAST(char*, __f->_ptr + __f->_avail); }
558
559 // Returns the number of characters remaining in the buffer, i.e.
560 // _FILE_[IO]_end(__f) - _FILE_[IO]_next(__f).
561 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->_avail; }
562
563 // Increments the current read/write position by 1, returning the
564 // character at the old position.
565 inline char& _FILE_I_preincr(FILE *__f)
566 { --__f->_avail; return *(char*) (++__f->_ptr); }
567 inline char& _FILE_I_postincr(FILE *__f)
568 { --__f->_avail; return *(char*) (__f->_ptr++); }
569 inline char& _FILE_I_predecr(FILE *__f)
570 { ++__f->_avail; return *(char*) (--__f->_ptr); }
571 inline char& _FILE_I_postdecr(FILE *__f)
572 { ++__f->_avail; return *(char*) (__f->_ptr--); }
573 inline void _FILE_I_bump(FILE *__f, int __n)
574 { __f->_ptr += __n; __f->_avail -= __n; }
575
576 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
577 __f->_base = __REINTERPRET_CAST(unsigned char*, __begin);
578 __f->_ptr = __REINTERPRET_CAST(unsigned char*, __next);
579 __f->_avail = __end - __next;
580 }
581 #endif // N_PLAT_NLM
582
583
584 # define _STLP_FILE_I_O_IDENTICAL
585
586 #elif defined(__DMC__)
587
588 inline int _FILE_fd(const FILE *__f) { return __f->_file; }
589
590 // Returns a pointer to the beginning of the buffer.
591 inline char* _FILE_I_begin(const FILE *__f) { return __f->_base; }
592
593 // Returns the current read/write position within the buffer.
594 inline char* _FILE_I_next(const FILE *__f) { return __f->_ptr; }
595
596 // Returns a pointer immediately past the end of the buffer.
597 inline char* _FILE_I_end(const FILE *__f) { return __f->_ptr + __f->_cnt; }
598
599 // Returns the number of characters remaining in the buffer, i.e.
600 // _FILE_[IO]_end(__f) - _FILE_[IO]_next(__f).
601 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->_cnt; }
602
603 // Increments the current read/write position by 1, returning the
604 // character at the NEW position.
605 inline char& _FILE_I_preincr(FILE *__f) { --__f->_cnt; return *(++__f->_ptr); }
606
607
608 // Increments the current read/write position by 1, returning the
609 // character at the old position.
610 inline char& _FILE_I_postincr(FILE *__f) { --__f->_cnt; return *(__f->_ptr++); }
611
612 // Decrements the current read/write position by 1, returning the
613 // character at the NEW position.
614 inline char& _FILE_I_predecr(FILE *__f) { ++__f->_cnt; return *(--__f->_ptr); }
615
616 // Decrements the current read/write position by 1, returning the
617 // character at the old position.
618 inline char& _FILE_I_postdecr(FILE *__f) { ++__f->_cnt; return *(__f->_ptr--); }
619
620 // Increments the current read/write position by __n.
621 inline void _FILE_I_bump(FILE *__f, int __n) { __f->_cnt -= __n; __f->_ptr += __n; }
622
623 // Sets the beginning of the bufer to __begin, the current read/write
624 // position to __next, and the buffer's past-the-end pointer to __end.
625 // If any of those pointers is null, then all of them must be null.
626 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end)
627 {
628 __f->_base = __begin;
629 __f->_ptr = __next;
630 __f->_cnt = __end - __next;
631 __f->_bufsiz = __end - __begin;
632 }
633
634 # define _STLP_FILE_I_O_IDENTICAL
635
636 #elif defined(__MRC__) || defined(__SC__) //*TY 02/24/2000 - added support for MPW
637
638 inline int _FILE_fd(const FILE *__f) { return __f->_file; }
639
640 // Returns a pointer to the beginning of the buffer.
641 inline char* _FILE_I_begin(const FILE *__f) { return (char*) __f->_base; }
642
643 // Returns the current read/write position within the buffer.
644 inline char* _FILE_I_next(const FILE *__f) { return (char*) __f->_ptr; }
645
646 // Returns a pointer immediately past the end of the buffer.
647 inline char* _FILE_I_end(const FILE *__f) { return (char*)__f->_end; }
648
649 // Returns the number of characters remaining in the buffer, i.e.
650 // _FILE_[IO]_end(__f) - _FILE_[IO]_next(__f).
651 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->_cnt; }
652
653 // Increments the current read/write position by 1, returning the
654 // character at the NEW position.
655 inline char& _FILE_I_preincr(FILE *__f) { --__f->_cnt; return*(char*) (++__f->_ptr); }
656
657
658 // Increments the current read/write position by 1, returning the
659 // character at the old position.
660 inline char& _FILE_I_postincr(FILE *__f) { --__f->_cnt; return*(char*) (__f->_ptr++); }
661
662 // Decrements the current read/write position by 1, returning the
663 // character at the NEW position.
664 inline char& _FILE_I_predecr(FILE *__f) { ++__f->_cnt; return*(char*) (--__f->_ptr); }
665
666 // Decrements the current read/write position by 1, returning the
667 // character at the old position.
668 inline char& _FILE_I_postdecr(FILE *__f) { ++__f->_cnt; return*(char*) (__f->_ptr--); }
669
670 // Increments the current read/write position by __n.
671 inline void _FILE_I_bump(FILE *__f, int __n) { __f->_cnt -= __n; __f->_ptr += __n; }
672
673 // Sets the beginning of the bufer to __begin, the current read/write
674 // position to __next, and the buffer's past-the-end pointer to __end.
675 // If any of those pointers is null, then all of them must be null.
676 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end)
677 {
678 __f->_base = (unsigned char*)__begin;
679 __f->_ptr = (unsigned char*)__next;
680 __f->_end = (unsigned char*)__end;
681 __f->_cnt = __end - __next;
682 __f->_size = __end - __begin;
683 }
684
685 # define _STLP_FILE_I_O_IDENTICAL
686
687 #elif defined (__MVS__)
688
689 typedef unsigned char* _File_ptr_type;
690
691 inline int _FILE_fd(const FILE *__f) { return fileno(__CONST_CAST(FILE
692 *,__f)); }
693 inline char* _FILE_I_begin(const FILE *__f) { return (char*)
694 __f->__fp->__bufPtr; }
695 inline char* _FILE_I_next(const FILE *__f) { return (char*)
696 __f->__fp->__bufPtr; }
697 inline char* _FILE_I_end(const FILE *__f)
698 { return (char*) __f->__fp->__bufPtr + __f->__fp->__countIn; }
699
700 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return
701 __f->__fp->__countIn; }
702
703 inline char& _FILE_I_preincr(FILE *__f)
704 { --__f->__fp->__countIn; return *(char*) (++__f->__fp->__bufPtr); }
705 inline char& _FILE_I_postincr(FILE *__f)
706 { --__f->__fp->__countIn; return *(char*) (__f->__fp->__bufPtr++); }
707 inline char& _FILE_I_predecr(FILE *__f)
708 { ++__f->__fp->__countIn; return *(char*) (--__f->__fp->__bufPtr); }
709 inline char& _FILE_I_postdecr(FILE *__f)
710 { ++__f->__fp->__countIn; return *(char*) (__f->__fp->__bufPtr--); }
711 inline void _FILE_I_bump(FILE *__f, int __n)
712 { __f->__fp->__bufPtr += __n; __f->__fp->__countIn -= __n; }
713
714 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char*
715 __end) {
716 // __f->_base = (_File_ptr_type) __begin;
717 if(__f->__fp) {
718 __f->__fp->__bufPtr = (_File_ptr_type) __next;
719 __f->__fp->__countIn = __end - __next;
720 }
721 }
722
723 inline char* _FILE_O_begin(const FILE *__f) { return (char*)__f->__fp->__bufPtr;}
724 inline char* _FILE_O_next(const FILE *__f) { return (char*) __f->__fp->__bufPtr;}
725 inline char* _FILE_O_end(const FILE *__f) { return (char*) __f->__fp->__bufPtr + __f->__fp->__countOut; }
726 inline ptrdiff_t _FILE_O_avail(const FILE *__f) { return __f->__fp->__countOut; }
727
728 inline char& _FILE_O_preincr(FILE *__f)
729 { --__f->__fp->__countOut; return *(char*) (++__f->__fp->__bufPtr); }
730 inline char& _FILE_O_postincr(FILE *__f)
731 { --__f->__fp->__countOut; return *(char*) (__f->__fp->__bufPtr++); }
732 inline char& _FILE_O_predecr(FILE *__f)
733 { ++__f->__fp->__countOut; return *(char*) (--__f->__fp->__bufPtr); }
734 inline char& _FILE_O_postdecr(FILE *__f)
735 { ++__f->__fp->__countOut; return *(char*) (__f->__fp->__bufPtr--); }
736 inline void _FILE_O_bump(FILE *__f, int __n)
737 { __f->__fp->__bufPtr += __n; __f->__fp->__countOut -= __n; }
738
739 inline void _FILE_O_set(FILE *__f, char* __begin, char* __next, char*
740 __end) {
741 // __f->_base = (_File_ptr_type) __begin;
742 if(__f->__fp) {
743 __f->__fp->__bufPtr = (_File_ptr_type) __next;
744 __f->__fp->__countOut = __end - __next;
745 }
746 }
747
748 #elif defined(__QNXNTO__)
749
750 inline int _FILE_fd(const FILE *__f) { return __f->_handle;
751 }
752 inline char* _FILE_I_begin(const FILE *__f) { return
753 (char*) __f->_base; }
754 inline char* _FILE_I_next(const FILE *__f) { return
755 (char*) __f->_ptr; }
756 inline char* _FILE_I_end(const FILE *__f)
757 { return (char*) __f->_ptr + __f->_cnt; }
758
759 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return
760 __f->_cnt; }
761
762 inline char& _FILE_I_preincr(FILE *__f)
763 { --__f->_cnt; return *(char*) (++__f->_ptr); }
764 inline char& _FILE_I_postincr(FILE *__f)
765 { --__f->_cnt; return *(char*) (__f->_ptr++); }
766 inline char& _FILE_I_predecr(FILE *__f)
767 { ++__f->_cnt; return *(char*) (--__f->_ptr); }
768 inline char& _FILE_I_postdecr(FILE *__f)
769 { ++__f->_cnt; return *(char*) (__f->_ptr--); }
770 inline void _FILE_I_bump(FILE *__f, int __n)
771 { __f->_ptr += __n; __f->_cnt -= __n; }
772
773 inline void _FILE_I_set(FILE *__f, char* __begin, char*
774 __next, char*
775 __end) {
776 __f->_base = (unsigned char*) __begin;
777 __f->_ptr = (unsigned char*) __next;
778 __f->_cnt = __end - __next;
779 }
780
781 # define _STLP_FILE_I_O_IDENTICAL
782
783 #elif defined(__WATCOMC__) // Nikolaev
784
785 inline int _FILE_fd (const FILE *__f) { return __f->_handle;}
786 inline char* _FILE_I_begin (const FILE *__f) { return __REINTERPRET_CAST(char*, __f->_link); }
787 inline char* _FILE_I_next (const FILE *__f) { return __REINTERPRET_CAST(char*, __f->_ptr); }
788 inline char* _FILE_I_end (const FILE *__f) { return __REINTERPRET_CAST(char*, __f->_ptr + __f->_cnt); }
789 inline ptrdiff_t _FILE_I_avail (const FILE *__f) { return __f->_cnt; }
790
791 inline char& _FILE_I_preincr(FILE *__f)
792 {
793 --__f->_cnt;
794 return *__REINTERPRET_CAST(char*, ++__f->_ptr);
795 }
796
797 inline char& _FILE_I_postincr(FILE *__f)
798 {
799 --__f->_cnt;
800 return *__REINTERPRET_CAST(char*, __f->_ptr++);
801 }
802
803 inline char& _FILE_I_predecr(FILE *__f)
804 {
805 ++__f->_cnt;
806 return *__REINTERPRET_CAST(char*, --__f->_ptr);
807 }
808
809 inline char& _FILE_I_postdecr(FILE *__f)
810 {
811 ++__f->_cnt;
812 return *__REINTERPRET_CAST(char*, __f->_ptr--);
813 }
814
815 inline void _FILE_I_bump(FILE *__f, int __n)
816 {
817 __f->_ptr += __n;
818 __f->_cnt -= __n;
819 }
820
821 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end)
822 {
823 __f->_link = __REINTERPRET_CAST(__stream_link*, __begin);
824 __f->_ptr = __REINTERPRET_CAST(unsigned char*, __next);
825 __f->_cnt = __end - __next;
826 }
827
828 # define _STLP_FILE_I_O_IDENTICAL
829
830 #elif defined (__Lynx__)
831
832 // the prototypes are taken from LynxOS patch for STLport 4.0
833 inline int _FILE_fd(const FILE *__f) { return __f->_fd; }
834 inline char* _FILE_I_begin(const FILE *__f) { return (char*) __f->_base; }
835 inline char* _FILE_I_next(const FILE *__f) { return (char*) __f->_ptr; }
836 inline char* _FILE_I_end(const FILE *__f)
837 { return (char*) __f->_ptr + __f->_cnt; }
838
839 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->_cnt; }
840
841 inline char& _FILE_I_preincr(FILE *__f)
842 { --__f->_cnt; return *(char*) (++__f->_ptr); }
843 inline char& _FILE_I_postincr(FILE *__f)
844 { --__f->_cnt; return *(char*) (__f->_ptr++); }
845 inline char& _FILE_I_predecr(FILE *__f)
846 { ++__f->_cnt; return *(char*) (--__f->_ptr); }
847 inline char& _FILE_I_postdecr(FILE *__f)
848 { ++__f->_cnt; return *(char*) (__f->_ptr--); }
849 inline void _FILE_I_bump(FILE *__f, int __n)
850 { __f->_ptr += __n; __f->_cnt -= __n; }
851
852 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
853 __f->_base = __begin;
854 __f->_ptr = __next;
855 __f->_cnt = __end - __next;
856 }
857 # define _STLP_FILE_I_O_IDENTICAL
858
859 #else /* A C library that we don't have an implementation for. */
860
861 # error The C++ I/O library is not configured for this compiler
862
863 #endif
864
865
866 // For most stdio's , input and output FILE manipulation is identical.
867 # ifdef _STLP_FILE_I_O_IDENTICAL
_FILE_O_begin(const FILE * __f)868 inline char* _FILE_O_begin(const FILE *__f) { return _FILE_I_begin(__f); }
_FILE_O_next(const FILE * __f)869 inline char* _FILE_O_next(const FILE *__f) { return _FILE_I_next(__f); }
_FILE_O_end(const FILE * __f)870 inline char* _FILE_O_end(const FILE *__f) { return _FILE_I_end(__f); }
871
_FILE_O_avail(const FILE * __f)872 inline ptrdiff_t _FILE_O_avail(const FILE *__f) { return _FILE_I_avail(__f); }
873
_FILE_O_preincr(FILE * __f)874 inline char& _FILE_O_preincr(FILE *__f) { return _FILE_I_preincr(__f); }
_FILE_O_postincr(FILE * __f)875 inline char& _FILE_O_postincr(FILE *__f) { return _FILE_I_postincr(__f); }
_FILE_O_predecr(FILE * __f)876 inline char& _FILE_O_predecr(FILE *__f) { return _FILE_I_predecr(__f); }
_FILE_O_postdecr(FILE * __f)877 inline char& _FILE_O_postdecr(FILE *__f) { return _FILE_I_postdecr(__f); }
878
_FILE_O_bump(FILE * __f,int __n)879 inline void _FILE_O_bump(FILE *__f, int __n) { _FILE_I_bump(__f, __n); }
_FILE_O_set(FILE * __f,char * __begin,char * __next,char * __end)880 inline void _FILE_O_set(FILE *__f, char* __begin, char* __next, char* __end)
881 { _FILE_I_set(__f, __begin, __next, __end); }
882 # endif
883
884 _STLP_END_NAMESPACE
885
886 #endif /* _STLP_STDIO_FILE_H */
887
888 // Local Variables:
889 // mode:C++
890 // End:
891