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