lib/c++/stlport/_stdio_file.h

   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
  85 inline int _FILE_fd(const FILE *__f) { return (int)::_fileno((FILE*)__f); }
  86
  87 # undef _STLP_FILE_I_O_IDENTICAL
  88
  89 // Implementation for the IRIX C library.
  90 // Solaris interface looks to be identical.
  91 #elif !defined(_STLP_USE_GLIBC) && \
  92     ( defined(__sgi) || \
  93       ( defined(__sun) && ! defined (_LP64) )  || \
  94       defined (__osf__) || defined(__DECCXX) || \
  95       (defined (_STLP_MSVC) && !defined (_STLP_WCE_EVC3)) || \
  96       defined (__ICL) || defined (__MINGW32__) || defined(__DJGPP) || defined (_AIX) || defined (_CRAY))
  97
  98 #if defined (_STLP_MSVC) || defined (__ICL) || defined (__MINGW32__) || defined(__DJGPP)
  99 typedef  char* _File_ptr_type;
 100 #else
 101 typedef  unsigned char* _File_ptr_type;
 102 #endif
 103
 104 inline int   _FILE_fd(const FILE *__f) { return __f->_file; }
 105 inline char* _FILE_I_begin(const FILE *__f) { return (char*) __f->_base; }
 106 inline char* _FILE_I_next(const FILE *__f) { return (char*) __f->_ptr; }
 107 inline char* _FILE_I_end(const FILE *__f)
 108   { return (char*) __f->_ptr + __f->_cnt; }
 109
 110 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->_cnt; }
 111
 112 inline char& _FILE_I_preincr(FILE *__f)
 113   { --__f->_cnt; return *(char*) (++__f->_ptr); }
 114 inline char& _FILE_I_postincr(FILE *__f)
 115   { --__f->_cnt; return *(char*) (__f->_ptr++); }
 116 inline char& _FILE_I_predecr(FILE *__f)
 117   { ++__f->_cnt; return *(char*) (--__f->_ptr); }
 118 inline char& _FILE_I_postdecr(FILE *__f)
 119   { ++__f->_cnt; return *(char*) (__f->_ptr--); }
 120 inline void  _FILE_I_bump(FILE *__f, int __n)
 121   { __f->_ptr += __n; __f->_cnt -= __n; }
 122
 123 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
 124   __f->_base = (_File_ptr_type) __begin;
 125   __f->_ptr  = (_File_ptr_type) __next;
 126   __f->_cnt  = __end - __next;
 127 }
 128
 129 # define _STLP_FILE_I_O_IDENTICAL 1
 130
 131 #elif defined(__EMX__)
 132
 133 inline int   _FILE_fd(const FILE* __f) { return __f->_handle; }
 134 inline char* _FILE_I_begin(const FILE* __f) { return (char*) __f->_buffer; }
 135 inline char* _FILE_I_next(const FILE* __f) { return (char*) __f->_ptr; }
 136 inline char* _FILE_I_end(const FILE* __f) { return (char *) __f->_ptr + __f->_rcount; }
 137 inline ptrdiff_t _FILE_I_avail(const FILE* __f) { return __f->_rcount; }
 138 inline char& _FILE_I_preincr(FILE* __f) { --__f->_rcount; return *(char*) (++__f->_ptr); }
 139 inline char& _FILE_I_postincr(FILE* __f) { --__f->_rcount; return *(char*) (__f->_ptr++); }
 140 inline char& _FILE_I_predecr(FILE* __f) { ++__f->_rcount; return *(char*) (--__f->_ptr); }
 141 inline char& _FILE_I_postdecr(FILE* __f) { ++__f->_rcount; return *(char*) (__f->_ptr--); }
 142 inline void  _FILE_I_bump(FILE* __f, int __n) { __f->_ptr += __n; __f->_rcount -= __n; }
 143 inline void _FILE_I_set(FILE* __f, char* __begin, char* __next, char* __end) {
 144   __f->_buffer = __begin;
 145   __f->_ptr  = __next;
 146   __f->_rcount  = __end - __next;
 147 }
 148
 149 inline char* _FILE_O_begin(const FILE* __f) { return (char*) __f->_buffer; }
 150 inline char* _FILE_O_next(const FILE* __f) { return (char*) __f->_ptr; }
 151 inline char* _FILE_O_end(const FILE* __f) { return (char*) __f->_ptr + __f->_wcount; }
 152 inline ptrdiff_t _FILE_O_avail(const FILE* __f) { return __f->_wcount; }
 153 inline char& _FILE_O_preincr(FILE* __f) { --__f->_wcount; return *(char*) (++__f->_ptr); }
 154 inline char& _FILE_O_postincr(FILE* __f) { --__f->_wcount; return *(char*) (__f->_ptr++); }
 155 inline char& _FILE_O_predecr(FILE* __f) { ++__f->_wcount; return *(char*) (--__f->_ptr); }
 156 inline char& _FILE_O_postdecr(FILE* __f) { ++__f->_wcount; return *(char*) (__f->_ptr--); }
 157 inline void _FILE_O_bump(FILE* __f, int __n) { __f->_ptr += __n; __f->_wcount -= __n; }
 158 inline void _FILE_O_set(FILE* __f, char* __begin, char* __next, char* __end) {
 159   __f->_buffer = __begin;
 160   __f->_ptr  = __next;
 161   __f->_wcount  = __end - __next;
 162 }
 163
 164
 165 # undef _STLP_FILE_I_O_IDENTICAL
 166
 167 # elif defined(_STLP_SCO_OPENSERVER) || defined(__NCR_SVR)
 168
 169 typedef  unsigned char* _File_ptr_type;
 170
 171 inline int   _FILE_fd(const FILE *__f) { return __f->__file; }
 172 inline char* _FILE_I_begin(const FILE *__f) { return (char*) __f->__base; }
 173 inline char* _FILE_I_next(const FILE *__f) { return (char*) __f->__ptr; }
 174 inline char* _FILE_I_end(const FILE *__f)
 175   { return (char*) __f->__ptr + __f->__cnt; }
 176
 177 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->__cnt; }
 178
 179 inline char& _FILE_I_preincr(FILE *__f)
 180   { --__f->__cnt; return *(char*) (++__f->__ptr); }
 181 inline char& _FILE_I_postincr(FILE *__f)
 182   { --__f->__cnt; return *(char*) (__f->__ptr++); }
 183 inline char& _FILE_I_predecr(FILE *__f)
 184   { ++__f->__cnt; return *(char*) (--__f->__ptr); }
 185 inline char& _FILE_I_postdecr(FILE *__f)
 186   { ++__f->__cnt; return *(char*) (__f->__ptr--); }
 187 inline void  _FILE_I_bump(FILE *__f, int __n)
 188   { __f->__ptr += __n; __f->__cnt -= __n; }
 189
 190 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
 191   __f->__base = (_File_ptr_type) __begin;
 192   __f->__ptr  = (_File_ptr_type) __next;
 193   __f->__cnt  = __end - __next;
 194 }
 195
 196 # define _STLP_FILE_I_O_IDENTICAL 1
 197
 198 # elif defined(__sun) && defined( _LP64)
 199
 200 typedef long _File_ptr_type;
 201
 202 inline int _FILE_fd(const FILE *__f) { return (int) __f->__pad[2]; }
 203 inline char* _FILE_I_begin(const FILE *__f) { return (char*)
 204 __f->__pad[1]; }
 205 inline char* _FILE_I_next(const FILE *__f) { return (char*)
 206 __f->__pad[0]; }
 207 inline char* _FILE_I_end(const FILE *__f)
 208 { return (char*) __f->__pad[0] + __f->__pad[3]; }
 209
 210 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->__pad[3]; }
 211
 212 inline char& _FILE_I_preincr(FILE *__f)
 213 { --__f->__pad[3]; return *(char*) (++__f->__pad[0]); }
 214 inline char& _FILE_I_postincr(FILE *__f)
 215 { --__f->__pad[3]; return *(char*) (__f->__pad[0]++); }
 216 inline char& _FILE_I_predecr(FILE *__f)
 217 { ++__f->__pad[3]; return *(char*) (--__f->__pad[0]); }
 218 inline char& _FILE_I_postdecr(FILE *__f)
 219 { ++__f->__pad[3]; return *(char*) (__f->__pad[0]--); }
 220 inline void _FILE_I_bump(FILE *__f, long __n)
 221 { __f->__pad[0] += __n; __f->__pad[3] -= __n; }
 222
 223 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char*
 224 __end) {
 225 __f->__pad[1] = (_File_ptr_type) __begin;
 226 __f->__pad[0] = (_File_ptr_type) __next;
 227 __f->__pad[3] = __end - __next;
 228 }
 229
 230 # define _STLP_FILE_I_O_IDENTICAL
 231
 232 #elif defined (__CYGWIN__) || defined(__FreeBSD__)  || defined(__NetBSD__) || defined(__OpenBSD__) \
 233   || defined(__amigaos__) || ( defined(__GNUC__) && defined(__APPLE__) )
 234
 235 inline int _FILE_fd(const FILE *__f) { return __f->_file; }
 236 inline char* _FILE_I_begin(const FILE *__f) { return (char*)   __f->_bf._base; }
 237 inline char* _FILE_I_next(const FILE *__f) { return (char*) __f->_p; }
 238 inline char* _FILE_I_end(const FILE *__f)
 239 { return (char*) __f->_p + __f->_r; }
 240
 241 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->_r; }
 242
 243 #if ( defined(__GNUC__) && defined(__APPLE__) )
 244 inline char& _FILE_I_preincr(FILE *__f)
 245 { --__f->_r; return *(char*) (++__f->_p); }
 246 inline char& _FILE_I_postincr(FILE *__f)
 247 { --__f->_r; return *(char*) (__f->_p++); }
 248 inline char& _FILE_I_predecr(FILE *__f)
 249 { ++__f->_r; return *(char*) (--__f->_p); }
 250 inline char& _FILE_I_postdecr(FILE *__f)
 251 { ++__f->_r; return *(char*) (__f->_p--); }
 252 inline void _FILE_I_bump(FILE *__f, int __n)
 253 { __f->_p += __n; __f->_r -= __n; }
 254 #else
 255 inline char& _FILE_I_preincr(FILE *__f)
 256 { --__f->_r; --__f->_bf._size; return *(char*) (++__f->_p); }
 257 inline char& _FILE_I_postincr(FILE *__f)
 258 { --__f->_r; --__f->_bf._size; return *(char*) (__f->_p++); }
 259 inline char& _FILE_I_predecr(FILE *__f)
 260 { ++__f->_r; ++ __f->_bf._size; return *(char*) (--__f->_p); }
 261 inline char& _FILE_I_postdecr(FILE *__f)
 262 { ++__f->_r; ++__f->_bf._size; return *(char*) (__f->_p--); }
 263 inline void _FILE_I_bump(FILE *__f, int __n)
 264 { __f->_p += __n; __f->_bf._size+=__n; __f->_r -= __n; }
 265 #endif
 266
 267 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
 268   __f->_bf._base = (unsigned char*) __begin;
 269   __f->_p = (unsigned char*) __next;
 270   __f->_r = __f->_bf._size = __end - __next;
 271 }
 272 inline char* _FILE_O_begin(const FILE *__f) { return (char*) __f->_bf._base; }
 273 inline char* _FILE_O_next(const FILE *__f) { return (char*) __f->_p; }
 274 inline char* _FILE_O_end(const FILE *__f)
 275 { return (char*) __f->_p + __f->_w; }
 276
 277 inline ptrdiff_t _FILE_O_avail(const FILE *__f) { return __f->_w; }
 278
 279 #if ( defined(__GNUC__) && defined(__APPLE__) )
 280 inline char& _FILE_O_preincr(FILE *__f)
 281 { --__f->_w; return *(char*) (++__f->_p); }
 282 inline char& _FILE_O_postincr(FILE *__f)
 283 { --__f->_w; return *(char*) (__f->_p++); }
 284 inline char& _FILE_O_predecr(FILE *__f)
 285 { ++__f->_w; return *(char*) (--__f->_p); }
 286 inline char& _FILE_O_postdecr(FILE *__f)
 287 { ++__f->_w; return *(char*) (__f->_p--); }
 288 inline void _FILE_O_bump(FILE *__f, int __n)
 289 { __f->_p += __n; __f->_w -= __n; }
 290 #else
 291 inline char& _FILE_O_preincr(FILE *__f)
 292 { --__f->_w; --__f->_bf._size; return *(char*) (++__f->_p); }
 293 inline char& _FILE_O_postincr(FILE *__f)
 294 { --__f->_w; --__f->_bf._size; return *(char*) (__f->_p++); }
 295 inline char& _FILE_O_predecr(FILE *__f)
 296 { ++__f->_w; ++__f->_bf._size; return *(char*) (--__f->_p); }
 297 inline char& _FILE_O_postdecr(FILE *__f)
 298 { ++__f->_w; ++__f->_bf._size; return *(char*) (__f->_p--); }
 299 inline void _FILE_O_bump(FILE *__f, int __n)
 300 { __f->_p += __n; __f->_bf._size+=__n; __f->_w -= __n; }
 301 #endif
 302
 303 inline void _FILE_O_set(FILE *__f, char* __begin, char* __next, char* __end) {
 304   __f->_bf._base = (unsigned char*) __begin;
 305   __f->_p = (unsigned char*) __next;
 306   __f->_w = __f->_bf._size = __end - __next;
 307 }
 308
 309 # undef _STLP_FILE_I_O_IDENTICAL
 310
 311 #elif defined(_STLP_USE_UCLIBC) /* should be before _STLP_USE_GLIBC */
 312 inline int   _FILE_fd(const FILE *__f) { return fileno(__CONST_CAST(FILE *,__f)); }
 313 #elif defined(_STLP_USE_GLIBC)
 314
 315 inline int   _FILE_fd(const FILE *__f) { return __f->_fileno; }
 316 inline char* _FILE_I_begin(const FILE *__f) { return __f->_IO_read_base; }
 317 inline char* _FILE_I_next(const FILE *__f)  { return __f->_IO_read_ptr; }
 318 inline char* _FILE_I_end(const FILE *__f)   { return __f->_IO_read_end; }
 319
 320 inline ptrdiff_t _FILE_I_avail(const FILE *__f)
 321   { return __f->_IO_read_end - __f->_IO_read_ptr; }
 322
 323 inline char& _FILE_I_preincr(FILE *__f)  { return *++__f->_IO_read_ptr; }
 324 inline char& _FILE_I_postincr(FILE *__f) { return *__f->_IO_read_ptr++; }
 325 inline char& _FILE_I_predecr(FILE *__f)  { return *--__f->_IO_read_ptr; }
 326 inline char& _FILE_I_postdecr(FILE *__f) { return *__f->_IO_read_ptr--; }
 327 inline void  _FILE_I_bump(FILE *__f, int __n) { __f->_IO_read_ptr += __n; }
 328
 329 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
 330   __f->_IO_read_base = __begin;
 331   __f->_IO_read_ptr  = __next;
 332   __f->_IO_read_end  = __end;
 333 }
 334
 335 inline char* _FILE_O_begin(const FILE *__f) { return __f->_IO_write_base; }
 336 inline char* _FILE_O_next(const FILE *__f)  { return __f->_IO_write_ptr; }
 337 inline char* _FILE_O_end(const FILE *__f)   { return __f->_IO_write_end; }
 338
 339 inline ptrdiff_t _FILE_O_avail(const FILE *__f)
 340   { return __f->_IO_write_end - __f->_IO_write_ptr; }
 341
 342 inline char& _FILE_O_preincr(FILE *__f)  { return *++__f->_IO_write_ptr; }
 343 inline char& _FILE_O_postincr(FILE *__f) { return *__f->_IO_write_ptr++; }
 344 inline char& _FILE_O_predecr(FILE *__f)  { return *--__f->_IO_write_ptr; }
 345 inline char& _FILE_O_postdecr(FILE *__f) { return *__f->_IO_write_ptr--; }
 346 inline void  _FILE_O_bump(FILE *__f, int __n) { __f->_IO_write_ptr += __n; }
 347
 348 inline void _FILE_O_set(FILE *__f, char* __begin, char* __next, char* __end) {
 349   __f->_IO_write_base = __begin;
 350   __f->_IO_write_ptr  = __next;
 351   __f->_IO_write_end  = __end;
 352
 353 }
 354
 355 #elif defined(__hpux) /* && defined(__hppa) && defined(__HP_aCC)) */
 356
 357 #ifndef _INCLUDE_HPUX_SOURCE
 358 extern "C" unsigned char *__bufendtab[];
 359 #  undef  _bufend
 360 #  define _bufend(__p) \
 361      (*(((__p)->__flag & _IOEXT)  ? &(((_FILEX *)(__p))->__bufendp)      \
 362              : &(__bufendtab[(__p) - __iob])))
 363
 364 #  define _bufsiz(__p)  (_bufend(__p) - (__p)->__base)
 365 #endif /* _INCLUDE_HPUX_SOURCE */
 366
 367 #if defined(_STLP_HPACC_BROKEN_BUFEND)
 368 #  undef  _bufend
 369 #  define _bufend(__p) \
 370      (*(((__p)->__flag & _IOEXT)  ? &((__REINTERPRET_CAST(_FILEX*,(__p)))->__bufendp)  \
 371                                : &(__bufendtab[__REINTERPRET_CAST(FILE*,(__p)) - __iob])))
 372 #endif
 373
 374 inline int   _FILE_fd(const FILE *__f) { return fileno(__CONST_CAST(FILE *,__f)); }
 375 inline char* _FILE_I_begin(const FILE *__f) { return (__REINTERPRET_CAST(char*, __f->__base)); }
 376 inline char* _FILE_I_next(const FILE *__f)  { return (__REINTERPRET_CAST(char*, __f->__ptr)); }
 377 inline char* _FILE_I_end(const FILE *__f)   { return (__REINTERPRET_CAST(char*, __f->__ptr +__f->__cnt)); }
 378
 379 inline ptrdiff_t _FILE_I_avail(const FILE *__f)  { return __f->__cnt; }
 380
 381 inline char& _FILE_I_preincr(FILE *__f)  { --__f->__cnt; return *__REINTERPRET_CAST(char*, ++__f->__ptr); }
 382 inline char& _FILE_I_postincr(FILE *__f) { --__f->__cnt; return *__REINTERPRET_CAST(char*, __f->__ptr++); }
 383 inline char& _FILE_I_predecr(FILE *__f)  { ++__f->__cnt; return *__REINTERPRET_CAST(char*,--__f->__ptr); }
 384 inline char& _FILE_I_postdecr(FILE *__f) { ++__f->__cnt; return *__REINTERPRET_CAST(char*,__f->__ptr--); }
 385 inline void  _FILE_I_bump(FILE *__f, int __n) { __f->__cnt -= __n; __f->__ptr += __n; }
 386
 387 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
 388 # if defined(__hpux)
 389    if( (unsigned long) (__f - &__iob[0]) > _NFILE)
 390         __f->__flag |= _IOEXT;  // used by stdio's _bufend macro and goodness knows what else...
 391 # endif
 392   __f->__cnt  = __end - __next;
 393   __f->__base = __REINTERPRET_CAST(unsigned char*, __begin);
 394   __f->__ptr  = __REINTERPRET_CAST(unsigned char*, __next);
 395   _bufend(__f) = __REINTERPRET_CAST(unsigned char*, __end);
 396 }
 397
 398 // For HPUX stdio, input and output FILE manipulation is identical.
 399
 400 # define _STLP_FILE_I_O_IDENTICAL
 401
 402 #elif defined (__BORLANDC__)
 403
 404 typedef unsigned char* _File_ptr_type;
 405
 406 inline int _FILE_fd(const FILE *__f) { return __f->fd; }
 407 inline char* _FILE_I_begin(const FILE *__f) { return (char*) __f->buffer;
 408 }
 409 inline char* _FILE_I_next(const FILE *__f)
 410 { return (char*)__f->curp; }
 411 inline char* _FILE_I_end(const FILE *__f)
 412 { return (char*) __f->curp + __f->level; }
 413
 414 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->level; }
 415
 416 inline char& _FILE_I_preincr(FILE *__f)
 417 { --__f->level; return *(char*) (++__f->curp); }
 418 inline char& _FILE_I_postincr(FILE *__f)
 419 { --__f->level; return *(char*) (__f->curp++); }
 420 inline char& _FILE_I_predecr(FILE *__f)
 421 { ++__f->level; return *(char*) (--__f->curp); }
 422 inline char& _FILE_I_postdecr(FILE *__f)
 423 { ++__f->level; return *(char*) (__f->curp--); }
 424 inline void _FILE_I_bump(FILE *__f, int __n)
 425 { __f->curp += __n; __f->level -= __n; }
 426
 427 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
 428   __f->buffer = (_File_ptr_type) __begin;
 429   __f->curp = (_File_ptr_type) __next;
 430   __f->level = __end - __next;
 431 }
 432
 433 # define _STLP_FILE_I_O_IDENTICAL
 434
 435 #elif defined( __MWERKS__ )
 436
 437 // using MWERKS-specific defines here to detect other OS targets
 438 // dwa: I'm not sure they provide fileno for all OS's, but this should
 439 // work for Win32 and WinCE
 440
 441 #ifndef N_PLAT_NLM
 442 // Hmm, at least for Novell NetWare __dest_os == __mac_os true too..
 443 // May be both __dest_os and __mac_os defined and empty?   - ptr
 444 # if __dest_os == __mac_os
 445 inline int   _FILE_fd(const FILE *__f) { return ::fileno(__CONST_CAST(FILE*, __f)); }
 446 # else
 447 inline int   _FILE_fd(const FILE *__f) { return ::_fileno(__CONST_CAST(FILE*, __f)); }
 448 # endif // __dest_os == __mac_os
 449
 450 //       Returns a pointer to the beginning of the buffer.
 451 inline char* _FILE_I_begin(const FILE *__f) { return __REINTERPRET_CAST(char*, __f->buffer); }
 452 //       Returns the current read/write position within the buffer.
 453 inline char* _FILE_I_next(const FILE *__f) { return __REINTERPRET_CAST(char*, __f->buffer_ptr); }
 454
 455 //       Returns a pointer immediately past the end of the buffer.
 456 inline char* _FILE_I_end(const FILE *__f) { return __REINTERPRET_CAST(char*, __f->buffer_ptr + __f->buffer_len); }
 457
 458 //       Returns the number of characters remaining in the buffer, i.e.
 459 //       _FILE_[IO]_end(__f) - _FILE_[IO]_next(__f).
 460 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->buffer_len; }
 461
 462 //       Increments the current read/write position by 1, returning the
 463 //       character at the old position.
 464 inline char& _FILE_I_preincr(FILE *__f)
 465   { --__f->buffer_len; return *(char*) (++__f->buffer_ptr); }
 466 inline char& _FILE_I_postincr(FILE *__f)
 467   { --__f->buffer_len; return *(char*) (__f->buffer_ptr++); }
 468 inline char& _FILE_I_predecr(FILE *__f)
 469   { ++__f->buffer_len; return *(char*) (--__f->buffer_ptr); }
 470 inline char& _FILE_I_postdecr(FILE *__f)
 471   { ++__f->buffer_len; return *(char*) (__f->buffer_ptr--); }
 472 inline void  _FILE_I_bump(FILE *__f, int __n)
 473   { __f->buffer_ptr += __n; __f->buffer_len -= __n; }
 474
 475 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
 476   __f->buffer = __REINTERPRET_CAST(unsigned char*, __begin);
 477   __f->buffer_ptr   = __REINTERPRET_CAST(unsigned char*, __next);
 478   __f->buffer_len  = __end - __next;
 479   __f->buffer_size = __end - __begin;
 480 }
 481 #else // N_PLAT_NLM   - ptr
 482 inline int   _FILE_fd(const FILE *__f) { return __f->_file; }
 483 inline char* _FILE_I_begin(const FILE *__f) { return __REINTERPRET_CAST(char*, __f->_base); }
 484 //       Returns the current read/write position within the buffer.
 485 inline char* _FILE_I_next(const FILE *__f) { return __REINTERPRET_CAST(char*, __f->_ptr); }
 486
 487 //       Returns a pointer immediately past the end of the buffer.
 488 inline char* _FILE_I_end(const FILE *__f) { return __REINTERPRET_CAST(char*, __f->_ptr + __f->_avail); }
 489
 490 //       Returns the number of characters remaining in the buffer, i.e.
 491 //       _FILE_[IO]_end(__f) - _FILE_[IO]_next(__f).
 492 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->_avail; }
 493
 494 //       Increments the current read/write position by 1, returning the
 495 //       character at the old position.
 496 inline char& _FILE_I_preincr(FILE *__f)
 497   { --__f->_avail; return *(char*) (++__f->_ptr); }
 498 inline char& _FILE_I_postincr(FILE *__f)
 499   { --__f->_avail; return *(char*) (__f->_ptr++); }
 500 inline char& _FILE_I_predecr(FILE *__f)
 501   { ++__f->_avail; return *(char*) (--__f->_ptr); }
 502 inline char& _FILE_I_postdecr(FILE *__f)
 503   { ++__f->_avail; return *(char*) (__f->_ptr--); }
 504 inline void  _FILE_I_bump(FILE *__f, int __n)
 505   { __f->_ptr += __n; __f->_avail -= __n; }
 506
 507 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
 508   __f->_base  = __REINTERPRET_CAST(unsigned char*, __begin);
 509   __f->_ptr   = __REINTERPRET_CAST(unsigned char*, __next);
 510   __f->_avail = __end - __next;
 511 }
 512 #endif // N_PLAT_NLM
 513
 514
 515 # define _STLP_FILE_I_O_IDENTICAL
 516
 517 #elif defined(__DMC__)
 518
 519 inline int   _FILE_fd(const FILE *__f) { return __f->_file; }
 520
 521 //       Returns a pointer to the beginning of the buffer.
 522 inline char* _FILE_I_begin(const FILE *__f) { return __f->_base; }
 523
 524 //       Returns the current read/write position within the buffer.
 525 inline char* _FILE_I_next(const FILE *__f) { return __f->_ptr; }
 526
 527 //       Returns a pointer immediately past the end of the buffer.
 528 inline char* _FILE_I_end(const FILE *__f) { return __f->_ptr + __f->_cnt; }
 529
 530 //       Returns the number of characters remaining in the buffer, i.e.
 531 //       _FILE_[IO]_end(__f) - _FILE_[IO]_next(__f).
 532 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->_cnt; }
 533
 534 //       Increments the current read/write position by 1, returning the
 535 //       character at the NEW position.
 536 inline char& _FILE_I_preincr(FILE *__f) { --__f->_cnt; return *(++__f->_ptr); }
 537
 538
 539 //       Increments the current read/write position by 1, returning the
 540 //       character at the old position.
 541 inline char& _FILE_I_postincr(FILE *__f) { --__f->_cnt; return *(__f->_ptr++); }
 542
 543 //       Decrements the current read/write position by 1, returning the
 544 //       character at the NEW position.
 545 inline char& _FILE_I_predecr(FILE *__f) { ++__f->_cnt; return *(--__f->_ptr); }
 546
 547 //       Decrements the current read/write position by 1, returning the
 548 //       character at the old position.
 549 inline char& _FILE_I_postdecr(FILE *__f) { ++__f->_cnt; return *(__f->_ptr--); }
 550
 551 //       Increments the current read/write position by __n.
 552 inline void _FILE_I_bump(FILE *__f, int __n) { __f->_cnt -= __n; __f->_ptr += __n; }
 553
 554 //       Sets the beginning of the bufer to __begin, the current read/write
 555 //       position to __next, and the buffer's past-the-end pointer to __end.
 556 //       If any of those pointers is null, then all of them must be null.
 557 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end)
 558 {
 559   __f->_base = __begin;
 560   __f->_ptr = __next;
 561   __f->_cnt = __end - __next;
 562   __f->_bufsiz = __end - __begin;
 563 }
 564
 565 # define _STLP_FILE_I_O_IDENTICAL
 566
 567 #elif defined(__MRC__) || defined(__SC__)    //*TY 02/24/2000 - added support for MPW
 568
 569 inline int   _FILE_fd(const FILE *__f) { return __f->_file; }
 570
 571 //       Returns a pointer to the beginning of the buffer.
 572 inline char* _FILE_I_begin(const FILE *__f) { return (char*) __f->_base; }
 573
 574 //       Returns the current read/write position within the buffer.
 575 inline char* _FILE_I_next(const FILE *__f) { return (char*) __f->_ptr; }
 576
 577 //       Returns a pointer immediately past the end of the buffer.
 578 inline char* _FILE_I_end(const FILE *__f) { return (char*)__f->_end; }
 579
 580 //       Returns the number of characters remaining in the buffer, i.e.
 581 //       _FILE_[IO]_end(__f) - _FILE_[IO]_next(__f).
 582 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->_cnt; }
 583
 584 //       Increments the current read/write position by 1, returning the
 585 //       character at the NEW position.
 586 inline char& _FILE_I_preincr(FILE *__f) { --__f->_cnt; return*(char*) (++__f->_ptr); }
 587
 588
 589 //       Increments the current read/write position by 1, returning the
 590 //       character at the old position.
 591 inline char& _FILE_I_postincr(FILE *__f) { --__f->_cnt; return*(char*) (__f->_ptr++); }
 592
 593 //       Decrements the current read/write position by 1, returning the
 594 //       character at the NEW position.
 595 inline char& _FILE_I_predecr(FILE *__f) { ++__f->_cnt; return*(char*) (--__f->_ptr); }
 596
 597 //       Decrements the current read/write position by 1, returning the
 598 //       character at the old position.
 599 inline char& _FILE_I_postdecr(FILE *__f) { ++__f->_cnt; return*(char*) (__f->_ptr--); }
 600
 601 //       Increments the current read/write position by __n.
 602 inline void _FILE_I_bump(FILE *__f, int __n) { __f->_cnt -= __n; __f->_ptr += __n; }
 603
 604 //       Sets the beginning of the bufer to __begin, the current read/write
 605 //       position to __next, and the buffer's past-the-end pointer to __end.
 606 //       If any of those pointers is null, then all of them must be null.
 607 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end)
 608 {
 609   __f->_base = (unsigned char*)__begin;
 610   __f->_ptr  = (unsigned char*)__next;
 611   __f->_end  = (unsigned char*)__end;
 612   __f->_cnt  = __end - __next;
 613   __f->_size = __end - __begin;
 614 }
 615
 616 # define _STLP_FILE_I_O_IDENTICAL
 617
 618 #elif defined (__MVS__)
 619
 620 typedef unsigned char* _File_ptr_type;
 621
 622 inline int _FILE_fd(const FILE *__f) { return fileno(__CONST_CAST(FILE
 623                   *,__f)); }
 624 inline char* _FILE_I_begin(const FILE *__f) { return (char*)
 625             __f->__fp->__bufPtr; }
 626 inline char* _FILE_I_next(const FILE *__f) { return (char*)
 627                  __f->__fp->__bufPtr; }
 628 inline char* _FILE_I_end(const FILE *__f)
 629 { return (char*) __f->__fp->__bufPtr + __f->__fp->__countIn; }
 630
 631 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return
 632                 __f->__fp->__countIn; }
 633
 634 inline char& _FILE_I_preincr(FILE *__f)
 635 { --__f->__fp->__countIn; return *(char*) (++__f->__fp->__bufPtr); }
 636 inline char& _FILE_I_postincr(FILE *__f)
 637 { --__f->__fp->__countIn; return *(char*) (__f->__fp->__bufPtr++); }
 638 inline char& _FILE_I_predecr(FILE *__f)
 639 { ++__f->__fp->__countIn; return *(char*) (--__f->__fp->__bufPtr); }
 640 inline char& _FILE_I_postdecr(FILE *__f)
 641 { ++__f->__fp->__countIn; return *(char*) (__f->__fp->__bufPtr--); }
 642 inline void _FILE_I_bump(FILE *__f, int __n)
 643 { __f->__fp->__bufPtr += __n; __f->__fp->__countIn -= __n; }
 644
 645 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char*
 646       __end) {
 647   // __f->_base = (_File_ptr_type) __begin;
 648   if(__f->__fp) {
 649     __f->__fp->__bufPtr = (_File_ptr_type) __next;
 650     __f->__fp->__countIn = __end - __next;
 651   }
 652 }
 653
 654 inline char* _FILE_O_begin(const FILE *__f) { return (char*)__f->__fp->__bufPtr;}
 655 inline char* _FILE_O_next(const FILE *__f) { return (char*) __f->__fp->__bufPtr;}
 656 inline char* _FILE_O_end(const FILE *__f) { return (char*) __f->__fp->__bufPtr + __f->__fp->__countOut; }
 657 inline ptrdiff_t _FILE_O_avail(const FILE *__f) { return __f->__fp->__countOut; }
 658
 659 inline char& _FILE_O_preincr(FILE *__f)
 660 { --__f->__fp->__countOut; return *(char*) (++__f->__fp->__bufPtr); }
 661 inline char& _FILE_O_postincr(FILE *__f)
 662 { --__f->__fp->__countOut; return *(char*) (__f->__fp->__bufPtr++); }
 663 inline char& _FILE_O_predecr(FILE *__f)
 664 { ++__f->__fp->__countOut; return *(char*) (--__f->__fp->__bufPtr); }
 665 inline char& _FILE_O_postdecr(FILE *__f)
 666 { ++__f->__fp->__countOut; return *(char*) (__f->__fp->__bufPtr--); }
 667 inline void _FILE_O_bump(FILE *__f, int __n)
 668 { __f->__fp->__bufPtr += __n; __f->__fp->__countOut -= __n; }
 669
 670 inline void _FILE_O_set(FILE *__f, char* __begin, char* __next, char*
 671       __end) {
 672   // __f->_base = (_File_ptr_type) __begin;
 673   if(__f->__fp) {
 674     __f->__fp->__bufPtr = (_File_ptr_type) __next;
 675     __f->__fp->__countOut = __end - __next;
 676   }
 677 }
 678
 679 #elif defined(__QNXNTO__)
 680
 681 inline int _FILE_fd(const FILE *__f) { return __f->_handle;
 682 }
 683 inline char* _FILE_I_begin(const FILE *__f) { return
 684                                                 (char*) __f->_base; }
 685 inline char* _FILE_I_next(const FILE *__f) { return
 686                                                (char*) __f->_ptr; }
 687 inline char* _FILE_I_end(const FILE *__f)
 688 { return (char*) __f->_ptr + __f->_cnt; }
 689
 690 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return
 691                                                     __f->_cnt; }
 692
 693 inline char& _FILE_I_preincr(FILE *__f)
 694 { --__f->_cnt; return *(char*) (++__f->_ptr); }
 695 inline char& _FILE_I_postincr(FILE *__f)
 696 { --__f->_cnt; return *(char*) (__f->_ptr++); }
 697 inline char& _FILE_I_predecr(FILE *__f)
 698 { ++__f->_cnt; return *(char*) (--__f->_ptr); }
 699 inline char& _FILE_I_postdecr(FILE *__f)
 700 { ++__f->_cnt; return *(char*) (__f->_ptr--); }
 701 inline void _FILE_I_bump(FILE *__f, int __n)
 702 { __f->_ptr += __n; __f->_cnt -= __n; }
 703
 704 inline void _FILE_I_set(FILE *__f, char* __begin, char*
 705                         __next, char*
 706                         __end) {
 707   __f->_base = (unsigned char*) __begin;
 708   __f->_ptr = (unsigned char*) __next;
 709   __f->_cnt = __end - __next;
 710 }
 711
 712 # define _STLP_FILE_I_O_IDENTICAL
 713
 714 #elif defined(__WATCOMC__)                   // Nikolaev
 715
 716 inline int       _FILE_fd      (const FILE *__f) { return __f->_handle;}
 717 inline char*     _FILE_I_begin (const FILE *__f) { return __REINTERPRET_CAST(char*, __f->_link); }
 718 inline char*     _FILE_I_next  (const FILE *__f) { return __REINTERPRET_CAST(char*, __f->_ptr); }
 719 inline char*     _FILE_I_end   (const FILE *__f) { return __REINTERPRET_CAST(char*, __f->_ptr + __f->_cnt); }
 720 inline ptrdiff_t _FILE_I_avail (const FILE *__f) { return __f->_cnt; }
 721
 722 inline char& _FILE_I_preincr(FILE *__f)
 723 {
 724   --__f->_cnt;
 725   return *__REINTERPRET_CAST(char*, ++__f->_ptr);
 726 }
 727
 728 inline char& _FILE_I_postincr(FILE *__f)
 729 {
 730   --__f->_cnt;
 731   return *__REINTERPRET_CAST(char*, __f->_ptr++);
 732 }
 733
 734 inline char& _FILE_I_predecr(FILE *__f)
 735 {
 736   ++__f->_cnt;
 737   return *__REINTERPRET_CAST(char*, --__f->_ptr);
 738 }
 739
 740 inline char& _FILE_I_postdecr(FILE *__f)
 741 {
 742   ++__f->_cnt;
 743   return *__REINTERPRET_CAST(char*, __f->_ptr--);
 744 }
 745
 746 inline void _FILE_I_bump(FILE *__f, int __n)
 747 {
 748   __f->_ptr += __n;
 749   __f->_cnt -= __n;
 750 }
 751
 752 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end)
 753 {
 754   __f->_link = __REINTERPRET_CAST(__stream_link*, __begin);
 755   __f->_ptr  = __REINTERPRET_CAST(unsigned char*, __next);
 756   __f->_cnt  = __end - __next;
 757 }
 758
 759 # define _STLP_FILE_I_O_IDENTICAL
 760
 761 #elif defined (__Lynx__)
 762
 763 // the prototypes are taken from LynxOS patch for STLport 4.0
 764 inline int   _FILE_fd(const FILE *__f) { return __f->_fd; }
 765 inline char* _FILE_I_begin(const FILE *__f) { return (char*) __f->_base; }
 766 inline char* _FILE_I_next(const FILE *__f) { return (char*) __f->_ptr; }
 767 inline char* _FILE_I_end(const FILE *__f)
 768   { return (char*) __f->_ptr + __f->_cnt; }
 769
 770 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->_cnt; }
 771
 772 inline char& _FILE_I_preincr(FILE *__f)
 773   { --__f->_cnt; return *(char*) (++__f->_ptr); }
 774 inline char& _FILE_I_postincr(FILE *__f)
 775   { --__f->_cnt; return *(char*) (__f->_ptr++); }
 776 inline char& _FILE_I_predecr(FILE *__f)
 777    { ++__f->_cnt; return *(char*) (--__f->_ptr); }
 778 inline char& _FILE_I_postdecr(FILE *__f)
 779   { ++__f->_cnt; return *(char*) (__f->_ptr--); }
 780 inline void  _FILE_I_bump(FILE *__f, int __n)
 781   { __f->_ptr += __n; __f->_cnt -= __n; }
 782
 783 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
 784   __f->_base = __begin;
 785   __f->_ptr  = __next;
 786   __f->_cnt  = __end - __next;
 787 }
 788 # define _STLP_FILE_I_O_IDENTICAL
 789
 790 #else  /* A C library that we don't have an implementation for. */
 791
 792 # error The C++ I/O library is not configured for this compiler
 793
 794 #endif
 795
 796
 797 // For most stdio's , input and output FILE manipulation is identical.
 798 # ifdef _STLP_FILE_I_O_IDENTICAL
 799 inline char* _FILE_O_begin(const FILE *__f) { return _FILE_I_begin(__f); }
 800 inline char* _FILE_O_next(const FILE *__f)  { return _FILE_I_next(__f); }
 801 inline char* _FILE_O_end(const FILE *__f)   { return _FILE_I_end(__f); }
 802
 803 inline ptrdiff_t _FILE_O_avail(const FILE *__f) { return _FILE_I_avail(__f); }
 804
 805 inline char& _FILE_O_preincr(FILE *__f)  { return _FILE_I_preincr(__f); }
 806 inline char& _FILE_O_postincr(FILE *__f) { return _FILE_I_postincr(__f); }
 807 inline char& _FILE_O_predecr(FILE *__f)  { return _FILE_I_predecr(__f); }
 808 inline char& _FILE_O_postdecr(FILE *__f) { return _FILE_I_postdecr(__f); }
 809
 810 inline void  _FILE_O_bump(FILE *__f, int __n) { _FILE_I_bump(__f, __n); }
 811 inline void _FILE_O_set(FILE *__f, char* __begin, char* __next, char* __end)
 812   { _FILE_I_set(__f, __begin, __next, __end); }
 813 # endif
 814
 815 _STLP_END_NAMESPACE
 816
 817 #endif /* _STLP_STDIO_FILE_H */
 818
 819 // Local Variables:
 820 // mode:C++
 821 // End: