test: epoc32/include/stdapis/stlport/stl/_stdio

     1 /*

     2  * © Portions copyright (c) 2006-2007 Nokia Corporation.  All rights reserved.

     3  *

     4  * Copyright (c) 1999

     5  * Silicon Graphics Computer Systems, Inc.

     6  *

     7  * Copyright (c) 1999

     8  * Boris Fomitchev

     9  *

    10  * This material is provided "as is", with absolutely no warranty expressed

    11  * or implied. Any use is at your own risk.

    12  *

    13  * Permission to use or copy this software for any purpose is hereby granted

    14  * without fee, provided the above notices are retained on all copies.

    15  * Permission to modify the code and to distribute modified code is granted,

    16  * provided the above notices are retained, and a notice that the code was

    17  * modified is included with the above copyright notice.

    18  *

    19  */

    22 // WARNING: This is an internal header file, included by other C++

    23 // standard library headers.  You should not attempt to use this header

    24 // file directly.

    27 #ifndef _STLP_STDIO_FILE_H

    28 #define _STLP_STDIO_FILE_H

    30 // This file provides a low-level interface between the internal

    31 // representation of struct FILE, from the C stdio library, and

    32 // the C++ I/O library.  The C++ I/O library views a FILE object as

    33 // a collection of three pointers: the beginning of the buffer, the

    34 // current read/write position, and the end of the buffer.

    36 // The interface:

    37 // - char* _FILE_[IO]_begin(const FILE *__f);

    38 //       Returns a pointer to the beginning of the buffer.

    39 // - char* _FILE_[IO]_next(const FILE *__f);

    40 //       Returns the current read/write position within the buffer.

    41 // - char* _FILE_[IO]_end(const FILE *__f);

    42 //       Returns a pointer immediately past the end of the buffer.

    43 // - char* _FILE_[IO]_avail(const FILE *__f);

    44 //       Returns the number of characters remaining in the buffer, i.e.

    45 //       _FILE_[IO]_end(__f) - _FILE_[IO]_next(__f).

    46 // - char& _FILE_[IO]_preincr(FILE *__f)

    47 //       Increments the current read/write position by 1, returning the

    48 //       character at the old position.

    49 // - char& _FILE_[IO]_postincr(FILE *__f)

    50 //       Increments the current read/write position by 1, returning the

    51 //       character at the old position.

    52 // - char& _FILE_[IO]_predecr(FILE *__f)

    53 //       Decrements the current read/write position by 1, returning the

    54 //       character at the old position.

    55 // - char& _FILE_[IO]_postdecr(FILE *__f)

    56 //       Decrements the current read/write position by 1, returning the

    57 //       character at the old position.

    58 // - void _FILE_[IO]_bump(FILE *__f, int __n)

    59 //       Increments the current read/write position by __n.

    60 // - void _FILE_[IO]_set(FILE *__f, char* __begin, char* __next, char* __end);

    61 //       Sets the beginning of the bufer to __begin, the current read/write

    62 //       position to __next, and the buffer's past-the-end pointer to __end.

    63 //       If any of those pointers is null, then all of them must be null.

    65 // Each function comes in two versions, one for a FILE used as an input

    66 // buffer and one for a FILE used as an output buffer.  In some stdio

    67 // implementations the two functions are identical, but in others they are

    68 // not.

    70 #ifndef _STLP_CSTDIO

    71 # include <cstdio>

    72 #endif

    73 #ifndef _STLP_CSTDDEF

    74 # include <cstddef>

    75 #endif

    77 #if defined(__MSL__)

    78 # include <unix.h>	// get the definition of fileno

    79 #endif

    81 _STLP_BEGIN_NAMESPACE

    83 #if !defined(_STLP_WINCE)

    84 //----------------------------------------------------------------------

    85 // Implementation for the IRIX C library.

    86 // Solaris interface looks to be identical.

    87 #if !defined(_STLP_USE_GLIBC) && \

    88     ( defined(__sgi) || \

    89       ( defined(__sun) && ! defined (_LP64) )  || \

    90       defined (__osf__) || defined(__DECCXX) || \

    91       defined (_STLP_MSVC) || defined (__ICL) || defined (__MINGW32__) || defined(__DJGPP) ||\

    92       defined (_AIX) || defined (_CRAY))

    94 #if defined ( _MSC_VER ) || defined (__ICL) || defined (__MINGW32__) || defined(__DJGPP)

    95 typedef  char* _File_ptr_type;

    96 #else

    97 typedef  unsigned char* _File_ptr_type;

    98 #endif

   100 inline int   _FILE_fd(const FILE *__f) { return __f->_file; }

   101 inline char* _FILE_I_begin(const FILE *__f) { return (char*) __f->_base; }

   102 inline char* _FILE_I_next(const FILE *__f) { return (char*) __f->_ptr; }

   103 inline char* _FILE_I_end(const FILE *__f)

   104   { return (char*) __f->_ptr + __f->_cnt; }

   106 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->_cnt; }

   108 inline char& _FILE_I_preincr(FILE *__f)

   109   { --__f->_cnt; return *(char*) (++__f->_ptr); }

   110 inline char& _FILE_I_postincr(FILE *__f)

   111   { --__f->_cnt; return *(char*) (__f->_ptr++); }

   112 inline char& _FILE_I_predecr(FILE *__f)

   113   { ++__f->_cnt; return *(char*) (--__f->_ptr); }

   114 inline char& _FILE_I_postdecr(FILE *__f)

   115   { ++__f->_cnt; return *(char*) (__f->_ptr--); }

   116 inline void  _FILE_I_bump(FILE *__f, int __n)

   117   { __f->_ptr += __n; __f->_cnt -= __n; }

   119 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {

   120   __f->_base = (_File_ptr_type) __begin;

   121   __f->_ptr  = (_File_ptr_type) __next;

   122   __f->_cnt  = __end - __next;

   123 }

   125 # define _STLP_FILE_I_O_IDENTICAL 1

   127 #elif defined(__EMX__)

   129 inline int   _FILE_fd(const FILE* __f) { return __f->_handle; }

   130 inline char* _FILE_I_begin(const FILE* __f) { return (char*) __f->_buffer; }

   131 inline char* _FILE_I_next(const FILE* __f) { return (char*) __f->_ptr; }

   132 inline char* _FILE_I_end(const FILE* __f) { return (char *) __f->_ptr + __f->_rcount; }

   133 inline ptrdiff_t _FILE_I_avail(const FILE* __f) { return __f->_rcount; }

   134 inline char& _FILE_I_preincr(FILE* __f) { --__f->_rcount; return *(char*) (++__f->_ptr); }

   135 inline char& _FILE_I_postincr(FILE* __f) { --__f->_rcount; return *(char*) (__f->_ptr++); }

   136 inline char& _FILE_I_predecr(FILE* __f) { ++__f->_rcount; return *(char*) (--__f->_ptr); }

   137 inline char& _FILE_I_postdecr(FILE* __f) { ++__f->_rcount; return *(char*) (__f->_ptr--); }

   138 inline void  _FILE_I_bump(FILE* __f, int __n) { __f->_ptr += __n; __f->_rcount -= __n; }

   139 inline void _FILE_I_set(FILE* __f, char* __begin, char* __next, char* __end) {

   140   __f->_buffer = __begin;

   141   __f->_ptr  = __next;

   142   __f->_rcount  = __end - __next;

   143 }

   145 inline char* _FILE_O_begin(const FILE* __f) { return (char*) __f->_buffer; }

   146 inline char* _FILE_O_next(const FILE* __f) { return (char*) __f->_ptr; }

   147 inline char* _FILE_O_end(const FILE* __f) { return (char*) __f->_ptr + __f->_wcount; }

   148 inline ptrdiff_t _FILE_O_avail(const FILE* __f) { return __f->_wcount; }

   149 inline char& _FILE_O_preincr(FILE* __f) { --__f->_wcount; return *(char*) (++__f->_ptr); }

   150 inline char& _FILE_O_postincr(FILE* __f) { --__f->_wcount; return *(char*) (__f->_ptr++); }

   151 inline char& _FILE_O_predecr(FILE* __f) { ++__f->_wcount; return *(char*) (--__f->_ptr); }

   152 inline char& _FILE_O_postdecr(FILE* __f) { ++__f->_wcount; return *(char*) (__f->_ptr--); }

   153 inline void _FILE_O_bump(FILE* __f, int __n) { __f->_ptr += __n; __f->_wcount -= __n; }

   154 inline void _FILE_O_set(FILE* __f, char* __begin, char* __next, char* __end) {

   155   __f->_buffer = __begin;

   156   __f->_ptr  = __next;

   157   __f->_wcount  = __end - __next;

   158 }

   161 # undef _STLP_FILE_I_O_IDENTICAL

   163 # elif defined(_STLP_SCO_OPENSERVER) || defined(__NCR_SVR)

   165 typedef  unsigned char* _File_ptr_type;

   167 inline int   _FILE_fd(const FILE *__f) { return __f->__file; }

   168 inline char* _FILE_I_begin(const FILE *__f) { return (char*) __f->__base; }

   169 inline char* _FILE_I_next(const FILE *__f) { return (char*) __f->__ptr; }

   170 inline char* _FILE_I_end(const FILE *__f)

   171   { return (char*) __f->__ptr + __f->__cnt; }

   173 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->__cnt; }

   175 inline char& _FILE_I_preincr(FILE *__f)

   176   { --__f->__cnt; return *(char*) (++__f->__ptr); }

   177 inline char& _FILE_I_postincr(FILE *__f)

   178   { --__f->__cnt; return *(char*) (__f->__ptr++); }

   179 inline char& _FILE_I_predecr(FILE *__f)

   180   { ++__f->__cnt; return *(char*) (--__f->__ptr); }

   181 inline char& _FILE_I_postdecr(FILE *__f)

   182   { ++__f->__cnt; return *(char*) (__f->__ptr--); }

   183 inline void  _FILE_I_bump(FILE *__f, int __n)

   184   { __f->__ptr += __n; __f->__cnt -= __n; }

   186 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {

   187   __f->__base = (_File_ptr_type) __begin;

   188   __f->__ptr  = (_File_ptr_type) __next;

   189   __f->__cnt  = __end - __next;

   190 }

   192 # define _STLP_FILE_I_O_IDENTICAL 1

   194 # elif defined(__sun) && defined( _LP64)

   196 typedef long _File_ptr_type;

   198 inline int _FILE_fd(const FILE *__f) { return (int) __f->__pad[2]; }

   199 inline char* _FILE_I_begin(const FILE *__f) { return (char*)

   200 __f->__pad[1]; }

   201 inline char* _FILE_I_next(const FILE *__f) { return (char*)

   202 __f->__pad[0]; }

   203 inline char* _FILE_I_end(const FILE *__f)

   204 { return (char*) __f->__pad[0] + __f->__pad[3]; }

   206 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->__pad[3]; }

   208 inline char& _FILE_I_preincr(FILE *__f)

   209 { --__f->__pad[3]; return *(char*) (++__f->__pad[0]); }

   210 inline char& _FILE_I_postincr(FILE *__f)

   211 { --__f->__pad[3]; return *(char*) (__f->__pad[0]++); }

   212 inline char& _FILE_I_predecr(FILE *__f)

   213 { ++__f->__pad[3]; return *(char*) (--__f->__pad[0]); }

   214 inline char& _FILE_I_postdecr(FILE *__f)

   215 { ++__f->__pad[3]; return *(char*) (__f->__pad[0]--); }

   216 inline void _FILE_I_bump(FILE *__f, long __n)

   217 { __f->__pad[0] += __n; __f->__pad[3] -= __n; }

   219 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char*

   220 __end) {

   221 __f->__pad[1] = (_File_ptr_type) __begin;

   222 __f->__pad[0] = (_File_ptr_type) __next;

   223 __f->__pad[3] = __end - __next;

   224 }

   226 # define _STLP_FILE_I_O_IDENTICAL

   228 #elif defined (__CYGWIN__) || defined(__FreeBSD__)  || defined(__NetBSD__) \

   229   || defined(__amigaos__) || ( defined(__GNUC__) && defined(__APPLE__) ) || defined (_STLP_VXWORKS_TORNADO) \

   230   || defined (__SYMBIAN32__)

   232 inline int _FILE_fd(const FILE *__f) { return __f->_file; }

   233 inline char* _FILE_I_begin(const FILE *__f) { return (char*)

   234 						__f->_bf._base; }

   235 inline char* _FILE_I_next(const FILE *__f) { return (char*) __f->_p; }

   236 inline char* _FILE_I_end(const FILE *__f)

   237 { return (char*) __f->_p + __f->_r; }

   239 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->_r; }

   241 inline char& _FILE_I_preincr(FILE *__f)

   242 { --__f->_r; --__f->_bf._size; return *(char*) (++__f->_p); }

   243 inline char& _FILE_I_postincr(FILE *__f)

   244 { --__f->_r; --__f->_bf._size; return *(char*) (__f->_p++); }

   245 inline char& _FILE_I_predecr(FILE *__f)

   246 { ++__f->_r; ++ __f->_bf._size; return *(char*) (--__f->_p); }

   247 inline char& _FILE_I_postdecr(FILE *__f)

   248 { ++__f->_r; ++__f->_bf._size; return *(char*) (__f->_p--); }

   249 inline void _FILE_I_bump(FILE *__f, int __n)

   250 { __f->_p += __n; __f->_bf._size+=__n; __f->_r -= __n; }

   252 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char*

   253 			__end) {

   254   __f->_bf._base = (unsigned char*) __begin;

   255   __f->_p = (unsigned char*) __next;

   256   __f->_r = __f->_bf._size = __end - __next;

   257 }

   258 inline char* _FILE_O_begin(const FILE *__f) { return (char*)

   259 						__f->_bf._base; }

   260 inline char* _FILE_O_next(const FILE *__f) { return (char*) __f->_p; }

   261 inline char* _FILE_O_end(const FILE *__f)

   262 { return (char*) __f->_p + __f->_w; }

   264 inline ptrdiff_t _FILE_O_avail(const FILE *__f) { return __f->_w; }

   266 inline char& _FILE_O_preincr(FILE *__f)

   267 { --__f->_w; --__f->_bf._size; return *(char*) (++__f->_p); }

   268 inline char& _FILE_O_postincr(FILE *__f)

   269 { --__f->_w; --__f->_bf._size; return *(char*) (__f->_p++); }

   270 inline char& _FILE_O_predecr(FILE *__f)

   271 { ++__f->_w; ++__f->_bf._size; return *(char*) (--__f->_p); }

   272 inline char& _FILE_O_postdecr(FILE *__f)

   273 { ++__f->_w; ++__f->_bf._size; return *(char*) (__f->_p--); }

   274 inline void _FILE_O_bump(FILE *__f, int __n)

   275 { __f->_p += __n; __f->_bf._size+=__n; __f->_w -= __n; }

   277 inline void _FILE_O_set(FILE *__f, char* __begin, char* __next, char*

   278 			__end) {

   279   __f->_bf._base = (unsigned char*) __begin;

   280   __f->_p = (unsigned char*) __next;

   281   __f->_w = __f->_bf._size = __end - __next;

   282 }

   284 # undef _STLP_FILE_I_O_IDENTICAL

   286 #elif defined(_STLP_USE_GLIBC)

   288 inline int   _FILE_fd(const FILE *__f) { return __f->_fileno; }

   289 inline char* _FILE_I_begin(const FILE *__f) { return __f->_IO_read_base; }

   290 inline char* _FILE_I_next(const FILE *__f)  { return __f->_IO_read_ptr; }

   291 inline char* _FILE_I_end(const FILE *__f)   { return __f->_IO_read_end; }

   293 inline ptrdiff_t _FILE_I_avail(const FILE *__f)

   294   { return __f->_IO_read_end - __f->_IO_read_ptr; }

   296 inline char& _FILE_I_preincr(FILE *__f)  { return *++__f->_IO_read_ptr; }

   297 inline char& _FILE_I_postincr(FILE *__f) { return *__f->_IO_read_ptr++; }

   298 inline char& _FILE_I_predecr(FILE *__f)  { return *--__f->_IO_read_ptr; }

   299 inline char& _FILE_I_postdecr(FILE *__f) { return *__f->_IO_read_ptr--; }

   300 inline void  _FILE_I_bump(FILE *__f, int __n) { __f->_IO_read_ptr += __n; }

   302 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {

   303   __f->_IO_read_base = __begin;

   304   __f->_IO_read_ptr  = __next;

   305   __f->_IO_read_end  = __end;

   306 }

   308 inline char* _FILE_O_begin(const FILE *__f) { return __f->_IO_write_base; }

   309 inline char* _FILE_O_next(const FILE *__f)  { return __f->_IO_write_ptr; }

   310 inline char* _FILE_O_end(const FILE *__f)   { return __f->_IO_write_end; }

   312 inline ptrdiff_t _FILE_O_avail(const FILE *__f)

   313   { return __f->_IO_write_end - __f->_IO_write_ptr; }

   315 inline char& _FILE_O_preincr(FILE *__f)  { return *++__f->_IO_write_ptr; }

   316 inline char& _FILE_O_postincr(FILE *__f) { return *__f->_IO_write_ptr++; }

   317 inline char& _FILE_O_predecr(FILE *__f)  { return *--__f->_IO_write_ptr; }

   318 inline char& _FILE_O_postdecr(FILE *__f) { return *__f->_IO_write_ptr--; }

   319 inline void  _FILE_O_bump(FILE *__f, int __n) { __f->_IO_write_ptr += __n; }

   321 inline void _FILE_O_set(FILE *__f, char* __begin, char* __next, char* __end) {

   322   __f->_IO_write_base = __begin;

   323   __f->_IO_write_ptr  = __next;

   324   __f->_IO_write_end  = __end;

   326 }

   328 #elif defined(__hpux) /* && defined(__hppa) && defined(__HP_aCC)) */

   330 #ifndef _INCLUDE_HPUX_SOURCE

   331 extern "C" unsigned char *__bufendtab[];

   332 #  undef  _bufend

   333 #  define _bufend(__p) \

   334      (*(((__p)->__flag & _IOEXT)  ? &(((_FILEX *)(__p))->__bufendp)      \

   335  				    : &(__bufendtab[(__p) - __iob])))

   337 #  define _bufsiz(__p)  (_bufend(__p) - (__p)->__base)

   338 #endif /* _INCLUDE_HPUX_SOURCE */

   340 #if defined(_STLP_HPACC_BROKEN_BUFEND)

   341 #  undef  _bufend

   342 #  define _bufend(__p) \

   343      (*(((__p)->__flag & _IOEXT)  ? &((__REINTERPRET_CAST(_FILEX*,(__p)))->__bufendp)  \

   344                                : &(__bufendtab[__REINTERPRET_CAST(FILE*,(__p)) - __iob])))

   345 #endif

   347 inline int   _FILE_fd(const FILE *__f) { return fileno(__CONST_CAST(FILE *,__f)); }

   348 inline char* _FILE_I_begin(const FILE *__f) { return (__REINTERPRET_CAST(char*, __f->__base)); }

   349 inline char* _FILE_I_next(const FILE *__f)  { return (__REINTERPRET_CAST(char*, __f->__ptr)); }

   350 inline char* _FILE_I_end(const FILE *__f)   { return (__REINTERPRET_CAST(char*, __f->__ptr +__f->__cnt)); }

   352 inline ptrdiff_t _FILE_I_avail(const FILE *__f)  { return __f->__cnt; }

   354 inline char& _FILE_I_preincr(FILE *__f)  { --__f->__cnt; return *__REINTERPRET_CAST(char*, ++__f->__ptr); }

   355 inline char& _FILE_I_postincr(FILE *__f) { --__f->__cnt; return *__REINTERPRET_CAST(char*, __f->__ptr++); }

   356 inline char& _FILE_I_predecr(FILE *__f)  { ++__f->__cnt; return *__REINTERPRET_CAST(char*,--__f->__ptr); }

   357 inline char& _FILE_I_postdecr(FILE *__f) { ++__f->__cnt; return *__REINTERPRET_CAST(char*,__f->__ptr--); }

   358 inline void  _FILE_I_bump(FILE *__f, int __n) { __f->__cnt -= __n; __f->__ptr += __n; }

   360 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {

   361 # if defined(__hpux)

   362    if( (unsigned long) (__f - &__iob[0]) > _NFILE)

   363         __f->__flag |= _IOEXT;  // used by stdio's _bufend macro and goodness knows what else...

   364 # endif

   365   __f->__cnt  = __end - __next;

   366   __f->__base = __REINTERPRET_CAST(unsigned char*, __begin);

   367   __f->__ptr  = __REINTERPRET_CAST(unsigned char*, __next);

   368   _bufend(__f) = __REINTERPRET_CAST(unsigned char*, __end);

   369 }

   371 // For HPUX stdio, input and output FILE manipulation is identical.

   373 # define _STLP_FILE_I_O_IDENTICAL

   375 #elif defined (__BORLANDC__)

   377 typedef unsigned char* _File_ptr_type;

   379 inline int _FILE_fd(const FILE *__f) { return __f->fd; }

   380 inline char* _FILE_I_begin(const FILE *__f) { return (char*) __f->buffer;

   381 }

   382 inline char* _FILE_I_next(const FILE *__f)

   383 { return (char*)__f->curp; }

   384 inline char* _FILE_I_end(const FILE *__f)

   385 { return (char*) __f->curp + __f->level; }

   387 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->level; }

   389 inline char& _FILE_I_preincr(FILE *__f)

   390 { --__f->level; return *(char*) (++__f->curp); }

   391 inline char& _FILE_I_postincr(FILE *__f)

   392 { --__f->level; return *(char*) (__f->curp++); }

   393 inline char& _FILE_I_predecr(FILE *__f)

   394 { ++__f->level; return *(char*) (--__f->curp); }

   395 inline char& _FILE_I_postdecr(FILE *__f)

   396 { ++__f->level; return *(char*) (__f->curp--); }

   397 inline void _FILE_I_bump(FILE *__f, int __n)

   398 { __f->curp += __n; __f->level -= __n; }

   400 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char*

   401 			__end) {

   402   __f->buffer = (_File_ptr_type) __begin;

   403   __f->curp = (_File_ptr_type) __next;

   404   __f->level = __end - __next;

   405 }

   407 # define _STLP_FILE_I_O_IDENTICAL

   409 #elif defined( __MWERKS__ )

   411 // using MWERKS-specific defines here to detect other OS targets

   412 // dwa: I'm not sure they provide fileno for all OS's, but this should

   413 // work for Win32 and WinCE

   414 # if __dest_os == __mac_os

   415 inline int   _FILE_fd(const FILE *__f) { return ::fileno(__CONST_CAST(FILE*, __f)); }

   416 # else

   417 inline int   _FILE_fd(const FILE *__f) { return ::_fileno(__CONST_CAST(FILE*, __f)); }

   418 # endif

   420 //       Returns a pointer to the beginning of the buffer.

   421 inline char* _FILE_I_begin(const FILE *__f) { return __REINTERPRET_CAST(char*, __f->buffer); }

   422 //       Returns the current read/write position within the buffer.

   423 inline char* _FILE_I_next(const FILE *__f) { return __REINTERPRET_CAST(char*, __f->buffer_ptr); }

   425 //       Returns a pointer immediately past the end of the buffer.

   426 inline char* _FILE_I_end(const FILE *__f) { return __REINTERPRET_CAST(char*, __f->buffer_ptr + __f->buffer_len); }

   428 //       Returns the number of characters remaining in the buffer, i.e.

   429 //       _FILE_[IO]_end(__f) - _FILE_[IO]_next(__f).

   430 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->buffer_len; }

   432 //       Increments the current read/write position by 1, returning the

   433 //       character at the old position.

   434 inline char& _FILE_I_preincr(FILE *__f)

   435   { --__f->buffer_len; return *(char*) (++__f->buffer_ptr); }

   436 inline char& _FILE_I_postincr(FILE *__f)

   437   { --__f->buffer_len; return *(char*) (__f->buffer_ptr++); }

   438 inline char& _FILE_I_predecr(FILE *__f)

   439   { ++__f->buffer_len; return *(char*) (--__f->buffer_ptr); }

   440 inline char& _FILE_I_postdecr(FILE *__f)

   441   { ++__f->buffer_len; return *(char*) (__f->buffer_ptr--); }

   442 inline void  _FILE_I_bump(FILE *__f, int __n)

   443   { __f->buffer_ptr += __n; __f->buffer_len -= __n; }

   445 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {

   446   __f->buffer = __REINTERPRET_CAST(unsigned char*, __begin);

   447   __f->buffer_ptr   = __REINTERPRET_CAST(unsigned char*, __next);

   448   __f->buffer_len  = __end - __next;

   449   __f->buffer_size = __end - __begin;

   450 }

   452 # define _STLP_FILE_I_O_IDENTICAL

   454 #elif defined(__DMC__)

   456 inline int   _FILE_fd(const FILE *__f) { return __f->_file; }

   458 //       Returns a pointer to the beginning of the buffer.

   459 inline char* _FILE_I_begin(const FILE *__f) { return __f->_base; }

   461 //       Returns the current read/write position within the buffer.

   462 inline char* _FILE_I_next(const FILE *__f) { return __f->_ptr; }

   464 //       Returns a pointer immediately past the end of the buffer.

   465 inline char* _FILE_I_end(const FILE *__f) { return __f->_ptr + __f->_cnt; }

   467 //       Returns the number of characters remaining in the buffer, i.e.

   468 //       _FILE_[IO]_end(__f) - _FILE_[IO]_next(__f).

   469 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->_cnt; }

   471 //       Increments the current read/write position by 1, returning the

   472 //       character at the NEW position.

   473 inline char& _FILE_I_preincr(FILE *__f) { --__f->_cnt; return *(++__f->_ptr); }

   476 //       Increments the current read/write position by 1, returning the

   477 //       character at the old position.

   478 inline char& _FILE_I_postincr(FILE *__f) { --__f->_cnt; return *(__f->_ptr++); }

   480 //       Decrements the current read/write position by 1, returning the

   481 //       character at the NEW position.

   482 inline char& _FILE_I_predecr(FILE *__f) { ++__f->_cnt; return *(--__f->_ptr); }

   484 //       Decrements the current read/write position by 1, returning the

   485 //       character at the old position.

   486 inline char& _FILE_I_postdecr(FILE *__f) { ++__f->_cnt; return *(__f->_ptr--); }

   488 //       Increments the current read/write position by __n.

   489 inline void _FILE_I_bump(FILE *__f, int __n) { __f->_cnt -= __n; __f->_ptr += __n; }

   491 //       Sets the beginning of the bufer to __begin, the current read/write

   492 //       position to __next, and the buffer's past-the-end pointer to __end.

   493 //       If any of those pointers is null, then all of them must be null.

   494 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end)

   495 {

   496 	__f->_base = __begin;

   497 	__f->_ptr = __next;

   498 	__f->_cnt = __end - __next;

   499 	__f->_bufsiz = __end - __begin;

   500 }

   502 # define _STLP_FILE_I_O_IDENTICAL

   504 #elif defined(__MRC__) || defined(__SC__)		//*TY 02/24/2000 - added support for MPW

   506 inline int   _FILE_fd(const FILE *__f) { return __f->_file; }

   508 //       Returns a pointer to the beginning of the buffer.

   509 inline char* _FILE_I_begin(const FILE *__f) { return (char*) __f->_base; }

   511 //       Returns the current read/write position within the buffer.

   512 inline char* _FILE_I_next(const FILE *__f) { return (char*) __f->_ptr; }

   514 //       Returns a pointer immediately past the end of the buffer.

   515 inline char* _FILE_I_end(const FILE *__f) { return (char*)__f->_end; }

   517 //       Returns the number of characters remaining in the buffer, i.e.

   518 //       _FILE_[IO]_end(__f) - _FILE_[IO]_next(__f).

   519 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->_cnt; }

   521 //       Increments the current read/write position by 1, returning the

   522 //       character at the NEW position.

   523 inline char& _FILE_I_preincr(FILE *__f) { --__f->_cnt; return*(char*) (++__f->_ptr); }

   526 //       Increments the current read/write position by 1, returning the

   527 //       character at the old position.

   528 inline char& _FILE_I_postincr(FILE *__f) { --__f->_cnt; return*(char*) (__f->_ptr++); }

   530 //       Decrements the current read/write position by 1, returning the

   531 //       character at the NEW position.

   532 inline char& _FILE_I_predecr(FILE *__f) { ++__f->_cnt; return*(char*) (--__f->_ptr); }

   534 //       Decrements the current read/write position by 1, returning the

   535 //       character at the old position.

   536 inline char& _FILE_I_postdecr(FILE *__f) { ++__f->_cnt; return*(char*) (__f->_ptr--); }

   538 //       Increments the current read/write position by __n.

   539 inline void _FILE_I_bump(FILE *__f, int __n) { __f->_cnt -= __n; __f->_ptr += __n; }

   541 //       Sets the beginning of the bufer to __begin, the current read/write

   542 //       position to __next, and the buffer's past-the-end pointer to __end.

   543 //       If any of those pointers is null, then all of them must be null.

   544 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end)

   545 {

   546 	__f->_base = (unsigned char*)__begin;

   547 	__f->_ptr  = (unsigned char*)__next;

   548 	__f->_end  = (unsigned char*)__end;

   549 	__f->_cnt  = __end - __next;

   550 	__f->_size = __end - __begin;

   551 }

   553 # define _STLP_FILE_I_O_IDENTICAL

   555 #elif defined (__MVS__)

   557 typedef unsigned char* _File_ptr_type;

   559 inline int _FILE_fd(const FILE *__f) { return fileno(__CONST_CAST(FILE

   560 								  *,__f)); }

   561 inline char* _FILE_I_begin(const FILE *__f) { return (char*)

   562 						__f->__fp->__bufPtr; }

   563 inline char* _FILE_I_next(const FILE *__f) { return (char*)

   564 					       __f->__fp->__bufPtr; }

   565 inline char* _FILE_I_end(const FILE *__f)

   566 { return (char*) __f->__fp->__bufPtr + __f->__fp->__countIn; }

   568 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return

   569 						    __f->__fp->__countIn; }

   571 inline char& _FILE_I_preincr(FILE *__f)

   572 { --__f->__fp->__countIn; return *(char*) (++__f->__fp->__bufPtr); }

   573 inline char& _FILE_I_postincr(FILE *__f)

   574 { --__f->__fp->__countIn; return *(char*) (__f->__fp->__bufPtr++); }

   575 inline char& _FILE_I_predecr(FILE *__f)

   576 { ++__f->__fp->__countIn; return *(char*) (--__f->__fp->__bufPtr); }

   577 inline char& _FILE_I_postdecr(FILE *__f)

   578 { ++__f->__fp->__countIn; return *(char*) (__f->__fp->__bufPtr--); }

   579 inline void _FILE_I_bump(FILE *__f, int __n)

   580 { __f->__fp->__bufPtr += __n; __f->__fp->__countIn -= __n; }

   582 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char*

   583 			__end) {

   584   // __f->_base = (_File_ptr_type) __begin;

   585   if(__f->__fp) {

   586     __f->__fp->__bufPtr = (_File_ptr_type) __next;

   587     __f->__fp->__countIn = __end - __next;

   588   }

   589 }

   591 inline char* _FILE_O_begin(const FILE *__f) { return (char*)__f->__fp->__bufPtr;}

   592 inline char* _FILE_O_next(const FILE *__f) { return (char*) __f->__fp->__bufPtr;}

   593 inline char* _FILE_O_end(const FILE *__f) { return (char*) __f->__fp->__bufPtr + __f->__fp->__countOut; }

   594 inline ptrdiff_t _FILE_O_avail(const FILE *__f) { return __f->__fp->__countOut; }

   596 inline char& _FILE_O_preincr(FILE *__f)

   597 { --__f->__fp->__countOut; return *(char*) (++__f->__fp->__bufPtr); }

   598 inline char& _FILE_O_postincr(FILE *__f)

   599 { --__f->__fp->__countOut; return *(char*) (__f->__fp->__bufPtr++); }

   600 inline char& _FILE_O_predecr(FILE *__f)

   601 { ++__f->__fp->__countOut; return *(char*) (--__f->__fp->__bufPtr); }

   602 inline char& _FILE_O_postdecr(FILE *__f)

   603 { ++__f->__fp->__countOut; return *(char*) (__f->__fp->__bufPtr--); }

   604 inline void _FILE_O_bump(FILE *__f, int __n)

   605 { __f->__fp->__bufPtr += __n; __f->__fp->__countOut -= __n; }

   607 inline void _FILE_O_set(FILE *__f, char* __begin, char* __next, char*

   608 			__end) {

   609   // __f->_base = (_File_ptr_type) __begin;

   610   if(__f->__fp) {

   611     __f->__fp->__bufPtr = (_File_ptr_type) __next;

   612     __f->__fp->__countOut = __end - __next;

   613   }

   614 }

   616 #elif defined(__QNXNTO__)

   618 inline int _FILE_fd(const FILE *__f) { return __f->_handle;

   619 }

   620 inline char* _FILE_I_begin(const FILE *__f) { return

   621                                                 (char*) __f->_base; }

   622 inline char* _FILE_I_next(const FILE *__f) { return

   623                                                (char*) __f->_ptr; }

   624 inline char* _FILE_I_end(const FILE *__f)

   625 { return (char*) __f->_ptr + __f->_cnt; }

   627 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return

   628                                                     __f->_cnt; }

   630 inline char& _FILE_I_preincr(FILE *__f)

   631 { --__f->_cnt; return *(char*) (++__f->_ptr); }

   632 inline char& _FILE_I_postincr(FILE *__f)

   633 { --__f->_cnt; return *(char*) (__f->_ptr++); }

   634 inline char& _FILE_I_predecr(FILE *__f)

   635 { ++__f->_cnt; return *(char*) (--__f->_ptr); }

   636 inline char& _FILE_I_postdecr(FILE *__f)

   637 { ++__f->_cnt; return *(char*) (__f->_ptr--); }

   638 inline void _FILE_I_bump(FILE *__f, int __n)

   639 { __f->_ptr += __n; __f->_cnt -= __n; }

   641 inline void _FILE_I_set(FILE *__f, char* __begin, char*

   642                         __next, char*

   643                         __end) {

   644   __f->_base = (unsigned char*) __begin;

   645   __f->_ptr = (unsigned char*) __next;

   646   __f->_cnt = __end - __next;

   647 }

   649 # define _STLP_FILE_I_O_IDENTICAL

   651 #elif defined(__WATCOMC__)                   // Nikolaev

   653 inline int       _FILE_fd      (const FILE *__f) { return __f->_handle;}

   654 inline char*     _FILE_I_begin (const FILE *__f) { return __REINTERPRET_CAST(char*, __f->_link); }

   655 inline char*     _FILE_I_next  (const FILE *__f) { return __REINTERPRET_CAST(char*, __f->_ptr); }

   656 inline char*     _FILE_I_end   (const FILE *__f) { return __REINTERPRET_CAST(char*, __f->_ptr + __f->_cnt); }

   657 inline ptrdiff_t _FILE_I_avail (const FILE *__f) { return __f->_cnt; }

   659 inline char& _FILE_I_preincr(FILE *__f)

   660 {

   661   --__f->_cnt;

   662   return *__REINTERPRET_CAST(char*, ++__f->_ptr);

   663 }

   665 inline char& _FILE_I_postincr(FILE *__f)

   666 {

   667   --__f->_cnt;

   668   return *__REINTERPRET_CAST(char*, __f->_ptr++);

   669 }

   671 inline char& _FILE_I_predecr(FILE *__f)

   672 {

   673   ++__f->_cnt;

   674   return *__REINTERPRET_CAST(char*, --__f->_ptr);

   675 }

   677 inline char& _FILE_I_postdecr(FILE *__f)

   678 {

   679   ++__f->_cnt;

   680   return *__REINTERPRET_CAST(char*, __f->_ptr--);

   681 }

   683 inline void _FILE_I_bump(FILE *__f, int __n)

   684 {

   685   __f->_ptr += __n;

   686   __f->_cnt -= __n;

   687 }

   689 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end)

   690 {

   691   __f->_link = __REINTERPRET_CAST(__stream_link*, __begin);

   692   __f->_ptr  = __REINTERPRET_CAST(unsigned char*, __next);

   693   __f->_cnt  = __end - __next;

   694 }

   696 # define _STLP_FILE_I_O_IDENTICAL

   698 #elif defined (__Lynx__)

   700 // the prototypes are taken from LynxOS patch for STLport 4.0

   701 inline int   _FILE_fd(const FILE *__f) { return __f->_fd; }

   702 inline char* _FILE_I_begin(const FILE *__f) { return (char*) __f->_base; }

   703 inline char* _FILE_I_next(const FILE *__f) { return (char*) __f->_ptr; }

   704 inline char* _FILE_I_end(const FILE *__f)

   705   { return (char*) __f->_ptr + __f->_cnt; }

   707 inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->_cnt; }

   709 inline char& _FILE_I_preincr(FILE *__f)

   710   { --__f->_cnt; return *(char*) (++__f->_ptr); }

   711 inline char& _FILE_I_postincr(FILE *__f)

   712   { --__f->_cnt; return *(char*) (__f->_ptr++); }

   713 inline char& _FILE_I_predecr(FILE *__f)

   714    { ++__f->_cnt; return *(char*) (--__f->_ptr); }

   715 inline char& _FILE_I_postdecr(FILE *__f)

   716   { ++__f->_cnt; return *(char*) (__f->_ptr--); }

   717 inline void  _FILE_I_bump(FILE *__f, int __n)

   718   { __f->_ptr += __n; __f->_cnt -= __n; }

   720 inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {

   721   __f->_base = __begin;

   722   __f->_ptr  = __next;

   723   __f->_cnt  = __end - __next;

   724 }

   725 # define _STLP_FILE_I_O_IDENTICAL

   727 #else  /* A C library that we don't have an implementation for. */

   728 #ifndef __SYMBIAN32__

   729 # error The C++ I/O library is not configured for this compiler

   730 #else

   731 #pragma message "The C++ I/O library is not configured for this compiler"

   732 #endif

   734 #endif

   737 // For most stdio's , input and output FILE manipulation is identical.

   738 # ifdef _STLP_FILE_I_O_IDENTICAL

   739 inline char* _FILE_O_begin(const FILE *__f) { return _FILE_I_begin(__f); }

   740 inline char* _FILE_O_next(const FILE *__f)  { return _FILE_I_next(__f); }

   741 inline char* _FILE_O_end(const FILE *__f)   { return _FILE_I_end(__f); }

   743 inline ptrdiff_t _FILE_O_avail(const FILE *__f) { return _FILE_I_avail(__f); }

   745 inline char& _FILE_O_preincr(FILE *__f)  { return _FILE_I_preincr(__f); }

   746 inline char& _FILE_O_postincr(FILE *__f) { return _FILE_I_postincr(__f); }

   747 inline char& _FILE_O_predecr(FILE *__f)  { return _FILE_I_predecr(__f); }

   748 inline char& _FILE_O_postdecr(FILE *__f) { return _FILE_I_postdecr(__f); }

   750 inline void  _FILE_O_bump(FILE *__f, int __n) { _FILE_I_bump(__f, __n); }

   751 inline void _FILE_O_set(FILE *__f, char* __begin, char* __next, char* __end)

   752   { _FILE_I_set(__f, __begin, __next, __end); }

   753 # endif

   755 #else

   756 inline int _FILE_fd(const FILE *__f) { return (int)::_fileno(__CONST_CAST(FILE *, __f)); }

   757 #endif /* _STLP_WINCE */

   759 _STLP_END_NAMESPACE

   761 #endif /* _STLP_STDIO_FILE_H */

   763 // Local Variables:

   764 // mode:C++

   765 // End:

author	William Roberts <williamr@symbian.org>
	Tue, 16 Mar 2010 16:12:26 +0000
branch	Symbian2
changeset 2	2fe1408b6811
parent 0	061f57f2323e
child 4	837f303aceeb
permissions	-rw-r--r--