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: