Intelligence.kdevelop: amw/src/cpp/cross/contextprediction/framework/thirdparty/STLport-4.5.1/stlport/stl/_stdio

00001 /*
00002  * Copyright (c) 1999
00003  * Silicon Graphics Computer Systems, Inc.
00004  *
00005  * Copyright (c) 1999 
00006  * Boris Fomitchev
00007  *
00008  * This material is provided "as is", with absolutely no warranty expressed
00009  * or implied. Any use is at your own risk.
00010  *
00011  * Permission to use or copy this software for any purpose is hereby granted 
00012  * without fee, provided the above notices are retained on all copies.
00013  * Permission to modify the code and to distribute modified code is granted,
00014  * provided the above notices are retained, and a notice that the code was
00015  * modified is included with the above copyright notice.
00016  *
00017  */ 
00018 
00019 
00020 // WARNING: This is an internal header file, included by other C++
00021 // standard library headers.  You should not attempt to use this header
00022 // file directly.
00023 
00024 
00025 #ifndef _STLP_STDIO_FILE_H
00026 #define _STLP_STDIO_FILE_H
00027 
00028 // This file provides a low-level interface between the internal 
00029 // representation of struct FILE, from the C stdio library, and 
00030 // the C++ I/O library.  The C++ I/O library views a FILE object as
00031 // a collection of three pointers: the beginning of the buffer, the
00032 // current read/write position, and the end of the buffer.
00033 
00034 // The interface:
00035 // - char* _FILE_[IO]_begin(const FILE& __f);
00036 //       Returns a pointer to the beginning of the buffer.
00037 // - char* _FILE_[IO]_next(const FILE& __f);
00038 //       Returns the current read/write position within the buffer.
00039 // - char* _FILE_[IO]_end(const FILE& __f);
00040 //       Returns a pointer immediately past the end of the buffer.
00041 // - char* _FILE_[IO]_avail(const FILE& __f);
00042 //       Returns the number of characters remaining in the buffer, i.e.
00043 //       _FILE_[IO]_end(__f) - _FILE_[IO]_next(__f).
00044 // - char& _FILE_[IO]_preincr(FILE& __f)
00045 //       Increments the current read/write position by 1, returning the 
00046 //       character at the old position.
00047 // - char& _FILE_[IO]_postincr(FILE& __f)
00048 //       Increments the current read/write position by 1, returning the 
00049 //       character at the old position.
00050 // - char& _FILE_[IO]_predecr(FILE& __f)
00051 //       Decrements the current read/write position by 1, returning the 
00052 //       character at the old position.
00053 // - char& _FILE_[IO]_postdecr(FILE& __f)
00054 //       Decrements the current read/write position by 1, returning the 
00055 //       character at the old position.
00056 // - void _FILE_[IO]_bump(FILE& __f, int __n)
00057 //       Increments the current read/write position by __n.
00058 // - void _FILE_[IO]_set(FILE& __f, char* __begin, char* __next, char* __end);
00059 //       Sets the beginning of the bufer to __begin, the current read/write
00060 //       position to __next, and the buffer's past-the-end pointer to __end.
00061 //       If any of those pointers is null, then all of them must be null.
00062 
00063 // Each function comes in two versions, one for a FILE used as an input
00064 // buffer and one for a FILE used as an output buffer.  In some stdio
00065 // implementations the two functions are identical, but in others they are
00066 // not.
00067 
00068 #ifndef _STLP_CSTDIO
00069 # include <cstdio>
00070 #endif
00071 #ifndef _STLP_CSTDDEF
00072 # include <cstddef>
00073 #endif
00074 
00075 #if defined(__MSL__)
00076 # include <unix.h>      // get the definition of fileno
00077 #endif
00078 
00079 _STLP_BEGIN_NAMESPACE
00080 
00081 //----------------------------------------------------------------------
00082 // Implementation for the IRIX C library.
00083 // Solaris interface looks to be identical.
00084 #if !defined(_STLP_USE_GLIBC) && \
00085     ( defined(__sgi) || \
00086       ( defined(__sun) && ! defined (_LP64) )  || \
00087       defined (__osf__) || defined(__DECCXX) || \
00088       defined (_STLP_MSVC) || defined (__ICL) || defined (__MINGW32__) || defined(__DJGPP) || defined (_AIX))
00089 
00090 #if (defined ( _MSC_VER )&& !defined (__SYMBIAN32__)) || defined (__ICL) || defined (__MINGW32__) || defined(__DJGPP)
00091 typedef  char* _File_ptr_type;
00092 #else
00093 typedef  unsigned char* _File_ptr_type;
00094 #endif
00095 
00096 inline int   _FILE_fd(const FILE& __f) { return __f._file; }
00097 inline char* _FILE_I_begin(const FILE& __f) { return (char*) __f._base; }
00098 inline char* _FILE_I_next(const FILE& __f) { return (char*) __f._ptr; }  
00099 inline char* _FILE_I_end(const FILE& __f)
00100   { return (char*) __f._ptr + __f._cnt; }
00101 
00102 inline ptrdiff_t _FILE_I_avail(const FILE& __f) { return __f._cnt; }
00103 
00104 inline char& _FILE_I_preincr(FILE& __f)
00105   { --__f._cnt; return *(char*) (++__f._ptr); }
00106 inline char& _FILE_I_postincr(FILE& __f)
00107   { --__f._cnt; return *(char*) (__f._ptr++); }
00108 inline char& _FILE_I_predecr(FILE& __f)
00109   { ++__f._cnt; return *(char*) (--__f._ptr); }
00110 inline char& _FILE_I_postdecr(FILE& __f)
00111   { ++__f._cnt; return *(char*) (__f._ptr--); }
00112 inline void  _FILE_I_bump(FILE& __f, int __n)
00113   { __f._ptr += __n; __f._cnt -= __n; }
00114 
00115 inline void _FILE_I_set(FILE& __f, char* __begin, char* __next, char* __end) {
00116   __f._base = (_File_ptr_type) __begin;
00117   __f._ptr  = (_File_ptr_type) __next;
00118   __f._cnt  = __end - __next;
00119 }
00120 
00121 # define _STLP_FILE_I_O_IDENTICAL 1
00122 
00123 # elif defined(_STLP_SCO_OPENSERVER)
00124 
00125 typedef  unsigned char* _File_ptr_type;
00126 
00127 inline int   _FILE_fd(const FILE& __f) { return __f.__file; }
00128 inline char* _FILE_I_begin(const FILE& __f) { return (char*) __f.__base; }
00129 inline char* _FILE_I_next(const FILE& __f) { return (char*) __f.__ptr; }
00130 inline char* _FILE_I_end(const FILE& __f)
00131   { return (char*) __f.__ptr + __f.__cnt; }
00132 
00133 inline ptrdiff_t _FILE_I_avail(const FILE& __f) { return __f.__cnt; }
00134 
00135 inline char& _FILE_I_preincr(FILE& __f)
00136   { --__f.__cnt; return *(char*) (++__f.__ptr); }
00137 inline char& _FILE_I_postincr(FILE& __f)
00138   { --__f.__cnt; return *(char*) (__f.__ptr++); }
00139 inline char& _FILE_I_predecr(FILE& __f)
00140   { ++__f.__cnt; return *(char*) (--__f.__ptr); }
00141 inline char& _FILE_I_postdecr(FILE& __f)
00142   { ++__f.__cnt; return *(char*) (__f.__ptr--); }
00143 inline void  _FILE_I_bump(FILE& __f, int __n)
00144   { __f.__ptr += __n; __f.__cnt -= __n; }
00145 
00146 inline void _FILE_I_set(FILE& __f, char* __begin, char* __next, char* __end) {
00147   __f.__base = (_File_ptr_type) __begin;
00148   __f.__ptr  = (_File_ptr_type) __next;
00149   __f.__cnt  = __end - __next;
00150 }
00151 
00152 # define _STLP_FILE_I_O_IDENTICAL 1
00153 
00154 # elif defined(__sun) && defined( _LP64)
00155 
00156 typedef long _File_ptr_type;
00157 
00158 inline int _FILE_fd(const FILE& __f) { return (int) __f.__pad[2]; }
00159 inline char* _FILE_I_begin(const FILE& __f) { return (char*)
00160 __f.__pad[1]; }
00161 inline char* _FILE_I_next(const FILE& __f) { return (char*)
00162 __f.__pad[0]; }
00163 inline char* _FILE_I_end(const FILE& __f)
00164 { return (char*) __f.__pad[0] + __f.__pad[3]; }
00165 
00166 inline ptrdiff_t _FILE_I_avail(const FILE& __f) { return __f.__pad[3]; }
00167 
00168 inline char& _FILE_I_preincr(FILE& __f)
00169 { --__f.__pad[3]; return *(char*) (++__f.__pad[0]); }
00170 inline char& _FILE_I_postincr(FILE& __f)
00171 { --__f.__pad[3]; return *(char*) (__f.__pad[0]++); }
00172 inline char& _FILE_I_predecr(FILE& __f)
00173 { ++__f.__pad[3]; return *(char*) (--__f.__pad[0]); }
00174 inline char& _FILE_I_postdecr(FILE& __f)
00175 { ++__f.__pad[3]; return *(char*) (__f.__pad[0]--); }
00176 inline void _FILE_I_bump(FILE& __f, long __n)
00177 { __f.__pad[0] += __n; __f.__pad[3] -= __n; }
00178 
00179 inline void _FILE_I_set(FILE& __f, char* __begin, char* __next, char*
00180 __end) {
00181 __f.__pad[1] = (_File_ptr_type) __begin;
00182 __f.__pad[0] = (_File_ptr_type) __next;
00183 __f.__pad[3] = __end - __next;
00184 }
00185 
00186 # define _STLP_FILE_I_O_IDENTICAL
00187 
00188 #elif defined (__CYGWIN__) || defined(__FreeBSD__)  || defined(__NetBSD__) || ( defined(__GNUC__) && defined(__APPLE__)  && !defined (__SYMBIAN32__)) || defined (__SYMBIAN32__)
00189 
00190 inline int _FILE_fd(const FILE& __f) { return __f._file; }
00191 inline char* _FILE_I_begin(const FILE& __f) { return (char*)
00192                                                 __f._bf._base; }
00193 inline char* _FILE_I_next(const FILE& __f) { return (char*) __f._p; } 
00194 inline char* _FILE_I_end(const FILE& __f)
00195 { return (char*) __f._p + __f._r; }
00196 
00197 inline ptrdiff_t _FILE_I_avail(const FILE& __f) { return __f._r; }
00198 
00199 inline char& _FILE_I_preincr(FILE& __f)
00200 { --__f._r; --__f._bf._size; return *(char*) (++__f._p); }
00201 inline char& _FILE_I_postincr(FILE& __f)
00202 { --__f._r; --__f._bf._size; return *(char*) (__f._p++); }
00203 inline char& _FILE_I_predecr(FILE& __f)
00204 { ++__f._r; ++ __f._bf._size; return *(char*) (--__f._p); }
00205 inline char& _FILE_I_postdecr(FILE& __f)
00206 { ++__f._r; ++__f._bf._size; return *(char*) (__f._p--); }
00207 inline void _FILE_I_bump(FILE& __f, int __n)
00208 { __f._p += __n; __f._bf._size+=__n; __f._r -= __n; }
00209 
00210 inline void _FILE_I_set(FILE& __f, char* __begin, char* __next, char*
00211                         __end) {
00212   __f._bf._base = (unsigned char*) __begin;
00213   __f._p = (unsigned char*) __next;
00214   __f._r = __f._bf._size = __end - __next;
00215 }
00216 inline char* _FILE_O_begin(const FILE& __f) { return (char*)
00217                                                 __f._bf._base; }
00218 inline char* _FILE_O_next(const FILE& __f) { return (char*) __f._p; } 
00219 inline char* _FILE_O_end(const FILE& __f)
00220 { return (char*) __f._p + __f._w; }
00221 
00222 inline ptrdiff_t _FILE_O_avail(const FILE& __f) { return __f._w; }
00223 
00224 inline char& _FILE_O_preincr(FILE& __f)
00225 { --__f._w; --__f._bf._size; return *(char*) (++__f._p); }
00226 inline char& _FILE_O_postincr(FILE& __f)
00227 { --__f._w; --__f._bf._size; return *(char*) (__f._p++); }
00228 inline char& _FILE_O_predecr(FILE& __f)
00229 { ++__f._w; ++__f._bf._size; return *(char*) (--__f._p); }
00230 inline char& _FILE_O_postdecr(FILE& __f)
00231 { ++__f._w; ++__f._bf._size; return *(char*) (__f._p--); }
00232 inline void _FILE_O_bump(FILE& __f, int __n)
00233 { __f._p += __n; __f._bf._size+=__n; __f._w -= __n; }
00234 
00235 inline void _FILE_O_set(FILE& __f, char* __begin, char* __next, char*
00236                         __end) {
00237   __f._bf._base = (unsigned char*) __begin;
00238   __f._p = (unsigned char*) __next;
00239   __f._w = __f._bf._size = __end - __next;
00240 }
00241 
00242 # undef _STLP_FILE_I_O_IDENTICAL
00243 
00244 #elif defined(_STLP_USE_GLIBC)
00245 
00246 inline int   _FILE_fd(const FILE& __f) { return __f._fileno; }
00247 inline char* _FILE_I_begin(const FILE& __f) { return __f._IO_read_base; }
00248 inline char* _FILE_I_next(const FILE& __f)  { return __f._IO_read_ptr; }
00249 inline char* _FILE_I_end(const FILE& __f)   { return __f._IO_read_end; }
00250 
00251 inline ptrdiff_t _FILE_I_avail(const FILE& __f) 
00252   { return __f._IO_read_end - __f._IO_read_ptr; }
00253 
00254 inline char& _FILE_I_preincr(FILE& __f)  { return *++__f._IO_read_ptr; }
00255 inline char& _FILE_I_postincr(FILE& __f) { return *__f._IO_read_ptr++; }
00256 inline char& _FILE_I_predecr(FILE& __f)  { return *--__f._IO_read_ptr; }
00257 inline char& _FILE_I_postdecr(FILE& __f) { return *__f._IO_read_ptr--; }
00258 inline void  _FILE_I_bump(FILE& __f, int __n) { __f._IO_read_ptr += __n; }
00259 
00260 inline void _FILE_I_set(FILE& __f, char* __begin, char* __next, char* __end) {
00261   __f._IO_read_base = __begin; 
00262   __f._IO_read_ptr  = __next; 
00263   __f._IO_read_end  = __end; 
00264 }
00265 
00266 inline char* _FILE_O_begin(const FILE& __f) { return __f._IO_write_base; }
00267 inline char* _FILE_O_next(const FILE& __f)  { return __f._IO_write_ptr; }
00268 inline char* _FILE_O_end(const FILE& __f)   { return __f._IO_write_end; }
00269 
00270 inline ptrdiff_t _FILE_O_avail(const FILE& __f) 
00271   { return __f._IO_write_end - __f._IO_write_ptr; }
00272 
00273 inline char& _FILE_O_preincr(FILE& __f)  { return *++__f._IO_write_ptr; }
00274 inline char& _FILE_O_postincr(FILE& __f) { return *__f._IO_write_ptr++; }
00275 inline char& _FILE_O_predecr(FILE& __f)  { return *--__f._IO_write_ptr; }
00276 inline char& _FILE_O_postdecr(FILE& __f) { return *__f._IO_write_ptr--; }
00277 inline void  _FILE_O_bump(FILE& __f, int __n) { __f._IO_write_ptr += __n; }
00278 
00279 inline void _FILE_O_set(FILE& __f, char* __begin, char* __next, char* __end) {
00280   __f._IO_write_base = __begin; 
00281   __f._IO_write_ptr  = __next; 
00282   __f._IO_write_end  = __end; 
00283 
00284 }
00285 
00286 #elif defined(__hpux) /* && defined(__hppa) && defined(__HP_aCC)) */
00287 
00288 #ifndef _INCLUDE_HPUX_SOURCE
00289 extern "C" unsigned char *__bufendtab[];
00290 #  undef  _bufend
00291 #  define _bufend(__p) \
00292      (*(((__p)->__flag & _IOEXT)  ? &(((_FILEX *)(__p))->__bufendp)      \
00293                                     : &(__bufendtab[(__p) - __iob])))
00294  
00295 #  define _bufsiz(__p)  (_bufend(__p) - (__p)->__base)
00296 #endif /* _INCLUDE_HPUX_SOURCE */
00297 
00298 #if defined(_STLP_HPACC_BROKEN_BUFEND)
00299 #  undef  _bufend
00300 #  define _bufend(__p) \
00301      (*(((__p)->__flag & _IOEXT)  ? &((__REINTERPRET_CAST(_FILEX*,(__p)))->__bufendp)  \
00302                                : &(__bufendtab[__REINTERPRET_CAST(FILE*,(__p)) - __iob])))
00303 #endif
00304 
00305 inline int   _FILE_fd(const FILE& __f) { return fileno(__CONST_CAST(FILE *,&__f)); }
00306 inline char* _FILE_I_begin(const FILE& __f) { return (__REINTERPRET_CAST(char*, __f.__base)); }
00307 inline char* _FILE_I_next(const FILE& __f)  { return (__REINTERPRET_CAST(char*, __f.__ptr)); }
00308 inline char* _FILE_I_end(const FILE& __f)   { return (__REINTERPRET_CAST(char*, __f.__ptr +__f.__cnt)); }
00309 
00310 inline ptrdiff_t _FILE_I_avail(const FILE& __f)  { return __f.__cnt; }
00311 
00312 inline char& _FILE_I_preincr(FILE& __f)  { --__f.__cnt; return *__REINTERPRET_CAST(char*, ++__f.__ptr); }
00313 inline char& _FILE_I_postincr(FILE& __f) { --__f.__cnt; return *__REINTERPRET_CAST(char*, __f.__ptr++); }
00314 inline char& _FILE_I_predecr(FILE& __f)  { ++__f.__cnt; return *__REINTERPRET_CAST(char*,--__f.__ptr); }
00315 inline char& _FILE_I_postdecr(FILE& __f) { ++__f.__cnt; return *__REINTERPRET_CAST(char*,__f.__ptr--); }
00316 inline void  _FILE_I_bump(FILE& __f, int __n) { __f.__cnt -= __n; __f.__ptr += __n; }
00317  
00318 inline void _FILE_I_set(FILE& __f, char* __begin, char* __next, char* __end) {
00319 # if defined(__hpux)
00320    if( (unsigned long) (&__f - &__iob[0]) > _NFILE)
00321         __f.__flag |= _IOEXT;  // used by stdio's _bufend macro and goodness knows what else...
00322 # endif
00323   __f.__cnt  = __end - __next; 
00324   __f.__base = __REINTERPRET_CAST(unsigned char*, __begin); 
00325   __f.__ptr  = __REINTERPRET_CAST(unsigned char*, __next);
00326   _bufend(&__f) = __REINTERPRET_CAST(unsigned char*, __end); 
00327 }
00328 
00329 // For HPUX stdio, input and output FILE manipulation is identical.
00330 
00331 # define _STLP_FILE_I_O_IDENTICAL
00332 
00333 #elif defined (__BORLANDC__)
00334 
00335 typedef unsigned char* _File_ptr_type;
00336 
00337 inline int _FILE_fd(const FILE& __f) { return __f.fd; }
00338 inline char* _FILE_I_begin(const FILE& __f) { return (char*) __f.buffer;
00339 }
00340 inline char* _FILE_I_next(const FILE& __f) 
00341 { return (char*)__f.curp; } 
00342 inline char* _FILE_I_end(const FILE& __f)
00343 { return (char*) __f.curp + __f.level; }
00344 
00345 inline ptrdiff_t _FILE_I_avail(const FILE& __f) { return __f.level; }
00346 
00347 inline char& _FILE_I_preincr(FILE& __f)
00348 { --__f.level; return *(char*) (++__f.curp); }
00349 inline char& _FILE_I_postincr(FILE& __f)
00350 { --__f.level; return *(char*) (__f.curp++); }
00351 inline char& _FILE_I_predecr(FILE& __f)
00352 { ++__f.level; return *(char*) (--__f.curp); }
00353 inline char& _FILE_I_postdecr(FILE& __f)
00354 { ++__f.level; return *(char*) (__f.curp--); }
00355 inline void _FILE_I_bump(FILE& __f, int __n)
00356 { __f.curp += __n; __f.level -= __n; }
00357 
00358 inline void _FILE_I_set(FILE& __f, char* __begin, char* __next, char*
00359                         __end) {
00360   __f.buffer = (_File_ptr_type) __begin;
00361   __f.curp = (_File_ptr_type) __next;
00362   __f.level = __end - __next;
00363 }
00364 
00365 # define _STLP_FILE_I_O_IDENTICAL
00366 
00367 #elif defined( __MWERKS__ )
00368 
00369 // using MWERKS-specific defines here to detect other OS targets
00370 // dwa: I'm not sure they provide fileno for all OS's, but this should
00371 // work for Win32 and WinCE
00372 # if __dest_os == __mac_os
00373 inline int   _FILE_fd(const FILE& __f) { return ::fileno(__CONST_CAST(FILE*, &__f)); }
00374 # else
00375 inline int   _FILE_fd(const FILE& __f) { return ::_fileno(__CONST_CAST(FILE*, &__f)); }
00376 # endif
00377 
00378 //       Returns a pointer to the beginning of the buffer.
00379 inline char* _FILE_I_begin(const FILE& __f) { return __REINTERPRET_CAST(char*, __f.buffer); }
00380 //       Returns the current read/write position within the buffer.
00381 inline char* _FILE_I_next(const FILE& __f) { return __REINTERPRET_CAST(char*, __f.buffer_ptr); }
00382 
00383 //       Returns a pointer immediately past the end of the buffer.
00384 inline char* _FILE_I_end(const FILE& __f) { return __REINTERPRET_CAST(char*, __f.buffer_ptr + __f.buffer_len); }
00385 
00386 //       Returns the number of characters remaining in the buffer, i.e.
00387 //       _FILE_[IO]_end(__f) - _FILE_[IO]_next(__f).
00388 inline ptrdiff_t _FILE_I_avail(const FILE& __f) { return __f.buffer_len; }
00389 
00390 //       Increments the current read/write position by 1, returning the 
00391 //       character at the old position.
00392 inline char& _FILE_I_preincr(FILE& __f)
00393   { --__f.buffer_len; return *(char*) (++__f.buffer_ptr); }
00394 inline char& _FILE_I_postincr(FILE& __f)
00395   { --__f.buffer_len; return *(char*) (__f.buffer_ptr++); }
00396 inline char& _FILE_I_predecr(FILE& __f)
00397   { ++__f.buffer_len; return *(char*) (--__f.buffer_ptr); }
00398 inline char& _FILE_I_postdecr(FILE& __f)
00399   { ++__f.buffer_len; return *(char*) (__f.buffer_ptr--); }
00400 inline void  _FILE_I_bump(FILE& __f, int __n)
00401   { __f.buffer_ptr += __n; __f.buffer_len -= __n; }
00402 
00403 inline void _FILE_I_set(FILE& __f, char* __begin, char* __next, char* __end) {
00404   __f.buffer = __REINTERPRET_CAST(unsigned char*, __begin);
00405   __f.buffer_ptr   = __REINTERPRET_CAST(unsigned char*, __next);
00406   __f.buffer_len  = __end - __next;
00407   __f.buffer_size = __end - __begin;
00408 }
00409 
00410 # define _STLP_FILE_I_O_IDENTICAL
00411 
00412 #elif defined(__MRC__) || defined(__SC__)               //*TY 02/24/2000 - added support for MPW
00413 
00414 inline int   _FILE_fd(const FILE& __f) { return __f._file; }
00415 
00416 //       Returns a pointer to the beginning of the buffer.
00417 inline char* _FILE_I_begin(const FILE& __f) { return (char*) __f._base; }
00418 
00419 //       Returns the current read/write position within the buffer.
00420 inline char* _FILE_I_next(const FILE& __f) { return (char*) __f._ptr; }
00421 
00422 //       Returns a pointer immediately past the end of the buffer.
00423 inline char* _FILE_I_end(const FILE& __f) { return (char*)__f._end; }
00424 
00425 //       Returns the number of characters remaining in the buffer, i.e.
00426 //       _FILE_[IO]_end(__f) - _FILE_[IO]_next(__f).
00427 inline ptrdiff_t _FILE_I_avail(const FILE& __f) { return __f._cnt; }
00428 
00429 //       Increments the current read/write position by 1, returning the 
00430 //       character at the NEW position.
00431 inline char& _FILE_I_preincr(FILE& __f) { --__f._cnt; return*(char*) (++__f._ptr); }
00432 
00433 
00434 //       Increments the current read/write position by 1, returning the 
00435 //       character at the old position.
00436 inline char& _FILE_I_postincr(FILE& __f) { --__f._cnt; return*(char*) (__f._ptr++); }
00437 
00438 //       Decrements the current read/write position by 1, returning the 
00439 //       character at the NEW position.
00440 inline char& _FILE_I_predecr(FILE& __f) { ++__f._cnt; return*(char*) (--__f._ptr); }
00441 
00442 //       Decrements the current read/write position by 1, returning the 
00443 //       character at the old position.
00444 inline char& _FILE_I_postdecr(FILE& __f) { ++__f._cnt; return*(char*) (__f._ptr--); }
00445 
00446 //       Increments the current read/write position by __n.
00447 inline void _FILE_I_bump(FILE& __f, int __n) { __f._cnt -= __n; __f._ptr += __n; }
00448 
00449 //       Sets the beginning of the bufer to __begin, the current read/write
00450 //       position to __next, and the buffer's past-the-end pointer to __end.
00451 //       If any of those pointers is null, then all of them must be null.
00452 inline void _FILE_I_set(FILE& __f, char* __begin, char* __next, char* __end)
00453 {
00454         __f._base = (unsigned char*)__begin;
00455         __f._ptr  = (unsigned char*)__next;
00456         __f._end  = (unsigned char*)__end;
00457         __f._cnt  = __end - __next;
00458         __f._size = __end - __begin;
00459 }
00460 
00461 # define _STLP_FILE_I_O_IDENTICAL
00462 
00463 #elif defined (__MVS__)
00464 
00465 typedef unsigned char* _File_ptr_type;
00466 
00467 inline int _FILE_fd(const FILE& __f) { return fileno(__CONST_CAST(FILE
00468                                                                   *,&__f)); }
00469 inline char* _FILE_I_begin(const FILE& __f) { return (char*)
00470                                                 __f.__fp->__bufPtr; }
00471 inline char* _FILE_I_next(const FILE& __f) { return (char*)
00472                                                __f.__fp->__bufPtr; }
00473 inline char* _FILE_I_end(const FILE& __f)
00474 { return (char*) __f.__fp->__bufPtr + __f.__fp->__countIn; }
00475 
00476 inline ptrdiff_t _FILE_I_avail(const FILE& __f) { return
00477                                                     __f.__fp->__countIn; }
00478 
00479 inline char& _FILE_I_preincr(FILE& __f)
00480 { --__f.__fp->__countIn; return *(char*) (++__f.__fp->__bufPtr); }
00481 inline char& _FILE_I_postincr(FILE& __f)
00482 { --__f.__fp->__countIn; return *(char*) (__f.__fp->__bufPtr++); }
00483 inline char& _FILE_I_predecr(FILE& __f)
00484 { ++__f.__fp->__countIn; return *(char*) (--__f.__fp->__bufPtr); }
00485 inline char& _FILE_I_postdecr(FILE& __f)
00486 { ++__f.__fp->__countIn; return *(char*) (__f.__fp->__bufPtr--); }
00487 inline void _FILE_I_bump(FILE& __f, int __n)
00488 { __f.__fp->__bufPtr += __n; __f.__fp->__countIn -= __n; }
00489 
00490 inline void _FILE_I_set(FILE& __f, char* __begin, char* __next, char*
00491                         __end) {
00492   // __f._base = (_File_ptr_type) __begin;
00493   if(__f.__fp) {
00494     __f.__fp->__bufPtr = (_File_ptr_type) __next;
00495     __f.__fp->__countIn = __end - __next;
00496   }
00497 }
00498 
00499 inline char* _FILE_O_begin(const FILE& __f) { return (char*)__f.__fp->__bufPtr;}
00500 inline char* _FILE_O_next(const FILE& __f) { return (char*) __f.__fp->__bufPtr;}
00501 inline char* _FILE_O_end(const FILE& __f) { return (char*) __f.__fp->__bufPtr + __f.__fp->__countOut; }
00502 inline ptrdiff_t _FILE_O_avail(const FILE& __f) { return __f.__fp->__countOut; }
00503 
00504 inline char& _FILE_O_preincr(FILE& __f)
00505 { --__f.__fp->__countOut; return *(char*) (++__f.__fp->__bufPtr); }
00506 inline char& _FILE_O_postincr(FILE& __f)
00507 { --__f.__fp->__countOut; return *(char*) (__f.__fp->__bufPtr++); }
00508 inline char& _FILE_O_predecr(FILE& __f)
00509 { ++__f.__fp->__countOut; return *(char*) (--__f.__fp->__bufPtr); }
00510 inline char& _FILE_O_postdecr(FILE& __f)
00511 { ++__f.__fp->__countOut; return *(char*) (__f.__fp->__bufPtr--); }
00512 inline void _FILE_O_bump(FILE& __f, int __n)
00513 { __f.__fp->__bufPtr += __n; __f.__fp->__countOut -= __n; }
00514 
00515 inline void _FILE_O_set(FILE& __f, char* __begin, char* __next, char*
00516                         __end) {
00517   // __f._base = (_File_ptr_type) __begin;
00518   if(__f.__fp) {
00519     __f.__fp->__bufPtr = (_File_ptr_type) __next;
00520     __f.__fp->__countOut = __end - __next;
00521   }
00522 }
00523 
00524 #elif defined(__QNXNTO__)
00525 
00526 inline int _FILE_fd(const FILE& __f) { return __f._handle;
00527 }
00528 inline char* _FILE_I_begin(const FILE& __f) { return
00529                                                 (char*) __f._base; }
00530 inline char* _FILE_I_next(const FILE& __f) { return
00531                                                (char*) __f._ptr; }
00532 inline char* _FILE_I_end(const FILE& __f)
00533 { return (char*) __f._ptr + __f._cnt; }
00534 
00535 inline ptrdiff_t _FILE_I_avail(const FILE& __f) { return
00536                                                     __f._cnt; }
00537 
00538 inline char& _FILE_I_preincr(FILE& __f)
00539 { --__f._cnt; return *(char*) (++__f._ptr); }
00540 inline char& _FILE_I_postincr(FILE& __f)
00541 { --__f._cnt; return *(char*) (__f._ptr++); }
00542 inline char& _FILE_I_predecr(FILE& __f)
00543 { ++__f._cnt; return *(char*) (--__f._ptr); }
00544 inline char& _FILE_I_postdecr(FILE& __f)
00545 { ++__f._cnt; return *(char*) (__f._ptr--); }
00546 inline void _FILE_I_bump(FILE& __f, int __n)
00547 { __f._ptr += __n; __f._cnt -= __n; }
00548 
00549 inline void _FILE_I_set(FILE& __f, char* __begin, char*
00550                         __next, char*
00551                         __end) {
00552   __f._base = (unsigned char*) __begin;
00553   __f._ptr = (unsigned char*) __next;
00554   __f._cnt = __end - __next;
00555 }
00556 
00557 # define _STLP_FILE_I_O_IDENTICAL
00558  
00559 #elif defined(__WATCOMC__)                   // Nikolaev
00560  
00561 inline int       _FILE_fd      (const FILE& __f) { return __f._handle;}
00562 inline char*     _FILE_I_begin (const FILE& __f) { return __REINTERPRET_CAST(char*, __f._link); }
00563 inline char*     _FILE_I_next  (const FILE& __f) { return __REINTERPRET_CAST(char*, __f._ptr); }
00564 inline char*     _FILE_I_end   (const FILE& __f) { return __REINTERPRET_CAST(char*, __f._ptr + __f._cnt); }
00565 inline ptrdiff_t _FILE_I_avail (const FILE& __f) { return __f._cnt; }
00566  
00567 inline char& _FILE_I_preincr(FILE& __f)
00568 {
00569   --__f._cnt;
00570   return *__REINTERPRET_CAST(char*, ++__f._ptr);
00571 }
00572  
00573 inline char& _FILE_I_postincr(FILE& __f)
00574 {
00575   --__f._cnt;
00576   return *__REINTERPRET_CAST(char*, __f._ptr++);
00577 }
00578 
00579 inline char& _FILE_I_predecr(FILE& __f)
00580 {
00581   ++__f._cnt;
00582   return *__REINTERPRET_CAST(char*, --__f._ptr);
00583 }
00584  
00585 inline char& _FILE_I_postdecr(FILE& __f)
00586 {
00587   ++__f._cnt;
00588   return *__REINTERPRET_CAST(char*, __f._ptr--);
00589 }
00590  
00591 inline void _FILE_I_bump(FILE& __f, int __n)
00592 {
00593   __f._ptr += __n;
00594   __f._cnt -= __n;
00595 }
00596  
00597 inline void _FILE_I_set(FILE& __f, char* __begin, char* __next, char* __end)
00598 {
00599   __f._link = __REINTERPRET_CAST(__stream_link*, __begin);
00600   __f._ptr  = __REINTERPRET_CAST(unsigned char*, __next);
00601   __f._cnt  = __end - __next;
00602 }
00603  
00604 # define _STLP_FILE_I_O_IDENTICAL
00605 
00606 #elif defined (__Lynx__)
00607 
00608 // the prototypes are taken from LynxOS patch for STLport 4.0
00609 inline int   _FILE_fd(const FILE& __f) { return __f._fd; }
00610 inline char* _FILE_I_begin(const FILE& __f) { return (char*) __f._base; }
00611 inline char* _FILE_I_next(const FILE& __f) { return (char*) __f._ptr; }  
00612 inline char* _FILE_I_end(const FILE& __f)
00613   { return (char*) __f._ptr + __f._cnt; }
00614  
00615 inline ptrdiff_t _FILE_I_avail(const FILE& __f) { return __f._cnt; }
00616  
00617 inline char& _FILE_I_preincr(FILE& __f)
00618   { --__f._cnt; return *(char*) (++__f._ptr); }
00619 inline char& _FILE_I_postincr(FILE& __f)
00620   { --__f._cnt; return *(char*) (__f._ptr++); }
00621 inline char& _FILE_I_predecr(FILE& __f)
00622    { ++__f._cnt; return *(char*) (--__f._ptr); }
00623 inline char& _FILE_I_postdecr(FILE& __f)
00624   { ++__f._cnt; return *(char*) (__f._ptr--); }
00625 inline void  _FILE_I_bump(FILE& __f, int __n)
00626   { __f._ptr += __n; __f._cnt -= __n; }
00627 
00628 inline void _FILE_I_set(FILE& __f, char* __begin, char* __next, char* __end) {
00629   __f._base = __begin;
00630   __f._ptr  = __next;
00631   __f._cnt  = __end - __next;
00632 }
00633 # define _STLP_FILE_I_O_IDENTICAL
00634 
00635 #elif defined (__SYMBIAN32__)
00636 
00637 // Symbian EPOC
00638 
00639 #else  /* A C library that we don't have an implementation for. */
00640 
00641 # error The C++ I/O library is not configured for this compiler
00642 
00643 #endif
00644 
00645 
00646 // For most stdio's , input and output FILE manipulation is identical.
00647 # ifdef _STLP_FILE_I_O_IDENTICAL
00648 inline char* _FILE_O_begin(const FILE& __f) { return _FILE_I_begin(__f); }
00649 inline char* _FILE_O_next(const FILE& __f)  { return _FILE_I_next(__f); }
00650 inline char* _FILE_O_end(const FILE& __f)   { return _FILE_I_end(__f); }
00651 
00652 inline ptrdiff_t _FILE_O_avail(const FILE& __f) { return _FILE_I_avail(__f); }
00653 
00654 inline char& _FILE_O_preincr(FILE& __f)  { return _FILE_I_preincr(__f); }
00655 inline char& _FILE_O_postincr(FILE& __f) { return _FILE_I_postincr(__f); }
00656 inline char& _FILE_O_predecr(FILE& __f)  { return _FILE_I_predecr(__f); }
00657 inline char& _FILE_O_postdecr(FILE& __f) { return _FILE_I_postdecr(__f); }
00658 
00659 inline void  _FILE_O_bump(FILE& __f, int __n) { _FILE_I_bump(__f, __n); }
00660 inline void _FILE_O_set(FILE& __f, char* __begin, char* __next, char* __end)
00661   { _FILE_I_set(__f, __begin, __next, __end); }
00662 # endif
00663 
00664 _STLP_END_NAMESPACE
00665 
00666 #endif /* _STLP_STDIO_FILE_H */
00667 
00668 // Local Variables:
00669 // mode:C++
00670 // End:
_stdio_file.h
