/project/jni/stlport/src/_stdio_file.h

https://github.com/aichunyu/FFPlayer · C Header · 823 lines · 545 code · 157 blank · 121 comment · 34 complexity · 7052993cd85d1111b23c4ce5e6987512 MD5 · raw file 

    

  1. /*
    2. 

  2.  * Copyright (c) 1999
    3. 

  3.  * Silicon Graphics Computer Systems, Inc.
    4. 

  4.  *
    5. 

  5.  * Copyright (c) 1999
    6. 

  6.  * Boris Fomitchev
    7. 

  7.  *
    8. 

  8.  * This material is provided "as is", with absolutely no warranty expressed
    9. 

  9.  * or implied. Any use is at your own risk.
    10. 

  10.  *
    11. 

  11.  * Permission to use or copy this software for any purpose is hereby granted
    12. 

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

  13.  * Permission to modify the code and to distribute modified code is granted,
    14. 

  14.  * provided the above notices are retained, and a notice that the code was
    15. 

  15.  * modified is included with the above copyright notice.
    16. 

  16.  *
    17. 

  17.  */
    18. 

  18. 

  19. 

  20. // WARNING: This is an internal header file, included by other C++
    21. 

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

  22. // file directly.
    23. 

  23. 

  24. 

  25. #ifndef _STLP_STDIO_FILE_H
    26. 

  26. #define _STLP_STDIO_FILE_H
    27. 

  27. 

  28. // This file provides a low-level interface between the internal
    29. 

  29. // representation of struct FILE, from the C stdio library, and
    30. 

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

  31. // a collection of three pointers: the beginning of the buffer, the
    32. 

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

  33. 

  34. // The interface:
    35. 

  35. // - char* _FILE_[IO]_begin(const FILE *__f);
    36. 

  36. //       Returns a pointer to the beginning of the buffer.
    37. 

  37. // - char* _FILE_[IO]_next(const FILE *__f);
    38. 

  38. //       Returns the current read/write position within the buffer.
    39. 

  39. // - char* _FILE_[IO]_end(const FILE *__f);
    40. 

  40. //       Returns a pointer immediately past the end of the buffer.
    41. 

  41. // - char* _FILE_[IO]_avail(const FILE *__f);
    42. 

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

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

  44. // - char& _FILE_[IO]_preincr(FILE *__f)
    45. 

  45. //       Increments the current read/write position by 1, returning the
    46. 

  46. //       character at the old position.
    47. 

  47. // - char& _FILE_[IO]_postincr(FILE *__f)
    48. 

  48. //       Increments the current read/write position by 1, returning the
    49. 

  49. //       character at the old position.
    50. 

  50. // - char& _FILE_[IO]_predecr(FILE *__f)
    51. 

  51. //       Decrements the current read/write position by 1, returning the
    52. 

  52. //       character at the old position.
    53. 

  53. // - char& _FILE_[IO]_postdecr(FILE *__f)
    54. 

  54. //       Decrements the current read/write position by 1, returning the
    55. 

  55. //       character at the old position.
    56. 

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

  57. //       Increments the current read/write position by __n.
    58. 

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

  59. //       Sets the beginning of the bufer to __begin, the current read/write
    60. 

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

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

  62. 

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

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

  65. // implementations the two functions are identical, but in others they are
    66. 

  66. // not.
    67. 

  67. 

  68. #ifndef _STLP_CSTDIO
    69. 

  69. # include <cstdio>
    70. 

  70. #endif
    71. 

  71. #ifndef _STLP_CSTDDEF
    72. 

  72. # include <cstddef>
    73. 

  73. #endif
    74. 

  74. 

  75. #if defined(__MSL__) && !defined(N_PLAT_NLM)
    76. 

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

  77. #endif
    78. 

  78. 

  79. _STLP_BEGIN_NAMESPACE
    80. 

  80. 

  81. //----------------------------------------------------------------------
    82. 

  82. // Implementation for eMbedded Visual C++ 3.0 and 4.2 (.NET)
    83. 

  83. #if defined (_STLP_WCE)
    84. 

  84. 

  85. inline int _FILE_fd(const FILE *__f) { return (int)::_fileno((FILE*)__f); }
    86. 

  86. 

  87. # undef _STLP_FILE_I_O_IDENTICAL
    88. 

  88. 

  89. // Implementation for the IRIX C library.
    90. 

  90. // Solaris interface looks to be identical.
    91. 

  91. #elif !defined(_STLP_USE_GLIBC) && \
    92. 

  92.     ( defined(__sgi) || \
    93. 

  93.       ( defined(__sun) && ! defined (_LP64) )  || \
    94. 

  94.       defined (__osf__) || defined(__DECCXX) || \
    95. 

  95.       (defined (_STLP_MSVC) && !defined (_STLP_WCE_EVC3)) || \
    96. 

  96.       defined (__ICL) || defined (__MINGW32__) || defined(__DJGPP) || defined (_AIX) || defined (_CRAY))
    97. 

  97. 

  98. #if defined (_STLP_MSVC) || defined (__ICL) || defined (__MINGW32__) || defined(__DJGPP)
    99. 

  99. typedef  char* _File_ptr_type;
    100. 

  100. #else
    101. 

  101. typedef  unsigned char* _File_ptr_type;
    102. 

  102. #endif
    103. 

  103. 

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

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

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

  107. inline char* _FILE_I_end(const FILE *__f)
    108. 

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

  109. 

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

  111. 

  112. inline char& _FILE_I_preincr(FILE *__f)
    113. 

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

  114. inline char& _FILE_I_postincr(FILE *__f)
    115. 

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

  116. inline char& _FILE_I_predecr(FILE *__f)
    117. 

  117.   { ++__f->_cnt; return *(char*) (--__f->_ptr); }
    118. 

  118. inline char& _FILE_I_postdecr(FILE *__f)
    119. 

  119.   { ++__f->_cnt; return *(char*) (__f->_ptr--); }
    120. 

  120. inline void  _FILE_I_bump(FILE *__f, int __n)
    121. 

  121.   { __f->_ptr += __n; __f->_cnt -= __n; }
    122. 

  122. 

  123. inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
    124. 

  124.   __f->_base = (_File_ptr_type) __begin;
    125. 

  125.   __f->_ptr  = (_File_ptr_type) __next;
    126. 

  126.   __f->_cnt  = __end - __next;
    127. 

  127. }
    128. 

  128. 

  129. # define _STLP_FILE_I_O_IDENTICAL 1
    130. 

  130. 

  131. #elif defined(__EMX__)
    132. 

  132. 

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

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

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

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

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

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

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

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

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

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

  143. inline void _FILE_I_set(FILE* __f, char* __begin, char* __next, char* __end) {
    144. 

  144.   __f->_buffer = __begin;
    145. 

  145.   __f->_ptr  = __next;
    146. 

  146.   __f->_rcount  = __end - __next;
    147. 

  147. }
    148. 

  148. 

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

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

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

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

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

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

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

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

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

  158. inline void _FILE_O_set(FILE* __f, char* __begin, char* __next, char* __end) {
    159. 

  159.   __f->_buffer = __begin;
    160. 

  160.   __f->_ptr  = __next;
    161. 

  161.   __f->_wcount  = __end - __next;
    162. 

  162. }
    163. 

  163. 

  164. 

  165. # undef _STLP_FILE_I_O_IDENTICAL
    166. 

  166. 

  167. # elif defined(_STLP_SCO_OPENSERVER) || defined(__NCR_SVR)
    168. 

  168. 

  169. typedef  unsigned char* _File_ptr_type;
    170. 

  170. 

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

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

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

  174. inline char* _FILE_I_end(const FILE *__f)
    175. 

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

  176. 

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

  178. 

  179. inline char& _FILE_I_preincr(FILE *__f)
    180. 

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

  181. inline char& _FILE_I_postincr(FILE *__f)
    182. 

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

  183. inline char& _FILE_I_predecr(FILE *__f)
    184. 

  184.   { ++__f->__cnt; return *(char*) (--__f->__ptr); }
    185. 

  185. inline char& _FILE_I_postdecr(FILE *__f)
    186. 

  186.   { ++__f->__cnt; return *(char*) (__f->__ptr--); }
    187. 

  187. inline void  _FILE_I_bump(FILE *__f, int __n)
    188. 

  188.   { __f->__ptr += __n; __f->__cnt -= __n; }
    189. 

  189. 

  190. inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
    191. 

  191.   __f->__base = (_File_ptr_type) __begin;
    192. 

  192.   __f->__ptr  = (_File_ptr_type) __next;
    193. 

  193.   __f->__cnt  = __end - __next;
    194. 

  194. }
    195. 

  195. 

  196. # define _STLP_FILE_I_O_IDENTICAL 1
    197. 

  197. 

  198. # elif defined(__sun) && defined( _LP64)
    199. 

  199. 

  200. typedef long _File_ptr_type;
    201. 

  201. 

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

  203. inline char* _FILE_I_begin(const FILE *__f) { return (char*)
    204. 

  204. __f->__pad[1]; }
    205. 

  205. inline char* _FILE_I_next(const FILE *__f) { return (char*)
    206. 

  206. __f->__pad[0]; }
    207. 

  207. inline char* _FILE_I_end(const FILE *__f)
    208. 

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

  209. 

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

  211. 

  212. inline char& _FILE_I_preincr(FILE *__f)
    213. 

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

  214. inline char& _FILE_I_postincr(FILE *__f)
    215. 

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

  216. inline char& _FILE_I_predecr(FILE *__f)
    217. 

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

  218. inline char& _FILE_I_postdecr(FILE *__f)
    219. 

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

  220. inline void _FILE_I_bump(FILE *__f, long __n)
    221. 

  221. { __f->__pad[0] += __n; __f->__pad[3] -= __n; }
    222. 

  222. 

  223. inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char*
    224. 

  224. __end) {
    225. 

  225. __f->__pad[1] = (_File_ptr_type) __begin;
    226. 

  226. __f->__pad[0] = (_File_ptr_type) __next;
    227. 

  227. __f->__pad[3] = __end - __next;
    228. 

  228. }
    229. 

  229. 

  230. # define _STLP_FILE_I_O_IDENTICAL
    231. 

  231. 

  232. #elif defined (__CYGWIN__) || defined(__FreeBSD__)  || defined(__NetBSD__) || defined(__OpenBSD__) \
    233. 

  233.   || defined(__amigaos__) || ( defined(__GNUC__) && defined(__APPLE__) )
    234. 

  234. 

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

  236. inline char* _FILE_I_begin(const FILE *__f) { return (char*)   __f->_bf._base; }
    237. 

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

  238. inline char* _FILE_I_end(const FILE *__f)
    239. 

  239. { return (char*) __f->_p + __f->_r; }
    240. 

  240. 

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

  242. 

  243. #if ( defined(__GNUC__) && defined(__APPLE__) )
    244. 

  244. inline char& _FILE_I_preincr(FILE *__f)
    245. 

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

  246. inline char& _FILE_I_postincr(FILE *__f)
    247. 

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

  248. inline char& _FILE_I_predecr(FILE *__f)
    249. 

  249. { ++__f->_r; return *(char*) (--__f->_p); }
    250. 

  250. inline char& _FILE_I_postdecr(FILE *__f)
    251. 

  251. { ++__f->_r; return *(char*) (__f->_p--); }
    252. 

  252. inline void _FILE_I_bump(FILE *__f, int __n)
    253. 

  253. { __f->_p += __n; __f->_r -= __n; }
    254. 

  254. #else
    255. 

  255. inline char& _FILE_I_preincr(FILE *__f)
    256. 

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

  257. inline char& _FILE_I_postincr(FILE *__f)
    258. 

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

  259. inline char& _FILE_I_predecr(FILE *__f)
    260. 

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

  261. inline char& _FILE_I_postdecr(FILE *__f)
    262. 

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

  263. inline void _FILE_I_bump(FILE *__f, int __n)
    264. 

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

  265. #endif
    266. 

  266. 

  267. inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
    268. 

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

  269.   __f->_p = (unsigned char*) __next;
    270. 

  270.   __f->_r = __f->_bf._size = __end - __next;
    271. 

  271. }
    272. 

  272. inline char* _FILE_O_begin(const FILE *__f) { return (char*) __f->_bf._base; }
    273. 

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

  274. inline char* _FILE_O_end(const FILE *__f)
    275. 

  275. { return (char*) __f->_p + __f->_w; }
    276. 

  276. 

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

  278. 

  279. #if ( defined(__GNUC__) && defined(__APPLE__) )
    280. 

  280. inline char& _FILE_O_preincr(FILE *__f)
    281. 

  281. { --__f->_w; return *(char*) (++__f->_p); }
    282. 

  282. inline char& _FILE_O_postincr(FILE *__f)
    283. 

  283. { --__f->_w; return *(char*) (__f->_p++); }
    284. 

  284. inline char& _FILE_O_predecr(FILE *__f)
    285. 

  285. { ++__f->_w; return *(char*) (--__f->_p); }
    286. 

  286. inline char& _FILE_O_postdecr(FILE *__f)
    287. 

  287. { ++__f->_w; return *(char*) (__f->_p--); }
    288. 

  288. inline void _FILE_O_bump(FILE *__f, int __n)
    289. 

  289. { __f->_p += __n; __f->_w -= __n; }
    290. 

  290. #else
    291. 

  291. inline char& _FILE_O_preincr(FILE *__f)
    292. 

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

  293. inline char& _FILE_O_postincr(FILE *__f)
    294. 

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

  295. inline char& _FILE_O_predecr(FILE *__f)
    296. 

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

  297. inline char& _FILE_O_postdecr(FILE *__f)
    298. 

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

  299. inline void _FILE_O_bump(FILE *__f, int __n)
    300. 

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

  301. #endif
    302. 

  302. 

  303. inline void _FILE_O_set(FILE *__f, char* __begin, char* __next, char* __end) {
    304. 

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

  305.   __f->_p = (unsigned char*) __next;
    306. 

  306.   __f->_w = __f->_bf._size = __end - __next;
    307. 

  307. }
    308. 

  308. 

  309. # undef _STLP_FILE_I_O_IDENTICAL
    310. 

  310. 

  311. #elif defined(_STLP_USE_UCLIBC) /* should be before _STLP_USE_GLIBC */
    312. 

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

  313. #elif defined(ANDROID) /* should be before _STLP_USE_GLIBC */
    314. 

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

  315. #elif defined(_STLP_USE_GLIBC)
    316. 

  316. 

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

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

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

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

  321. 

  322. inline ptrdiff_t _FILE_I_avail(const FILE *__f)
    323. 

  323.   { return __f->_IO_read_end - __f->_IO_read_ptr; }
    324. 

  324. 

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

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

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

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

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

  330. 

  331. inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
    332. 

  332.   __f->_IO_read_base = __begin;
    333. 

  333.   __f->_IO_read_ptr  = __next;
    334. 

  334.   __f->_IO_read_end  = __end;
    335. 

  335. }
    336. 

  336. 

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

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

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

  340. 

  341. inline ptrdiff_t _FILE_O_avail(const FILE *__f)
    342. 

  342.   { return __f->_IO_write_end - __f->_IO_write_ptr; }
    343. 

  343. 

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

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

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

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

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

  349. 

  350. inline void _FILE_O_set(FILE *__f, char* __begin, char* __next, char* __end) {
    351. 

  351.   __f->_IO_write_base = __begin;
    352. 

  352.   __f->_IO_write_ptr  = __next;
    353. 

  353.   __f->_IO_write_end  = __end;
    354. 

  354. 

  355. }
    356. 

  356. 

  357. #elif defined(__hpux) /* && defined(__hppa) && defined(__HP_aCC)) */
    358. 

  358. 

  359. #ifndef _INCLUDE_HPUX_SOURCE
    360. 

  360. extern "C" unsigned char *__bufendtab[];
    361. 

  361. #  undef  _bufend
    362. 

  362. #  define _bufend(__p) \
    363. 

  363.      (*(((__p)->__flag & _IOEXT)  ? &(((_FILEX *)(__p))->__bufendp)      \
    364. 

  364.              : &(__bufendtab[(__p) - __iob])))
    365. 

  365. 

  366. #  define _bufsiz(__p)  (_bufend(__p) - (__p)->__base)
    367. 

  367. #endif /* _INCLUDE_HPUX_SOURCE */
    368. 

  368. 

  369. #if defined(_STLP_HPACC_BROKEN_BUFEND)
    370. 

  370. #  undef  _bufend
    371. 

  371. #  define _bufend(__p) \
    372. 

  372.      (*(((__p)->__flag & _IOEXT)  ? &((__REINTERPRET_CAST(_FILEX*,(__p)))->__bufendp)  \
    373. 

  373.                                : &(__bufendtab[__REINTERPRET_CAST(FILE*,(__p)) - __iob])))
    374. 

  374. #endif
    375. 

  375. 

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

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

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

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

  380. 

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

  382. 

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

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

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

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

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

  388. 

  389. inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
    390. 

  390. # if defined(__hpux)
    391. 

  391.    if( (unsigned long) (__f - &__iob[0]) > _NFILE)
    392. 

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

  393. # endif
    394. 

  394.   __f->__cnt  = __end - __next;
    395. 

  395.   __f->__base = __REINTERPRET_CAST(unsigned char*, __begin);
    396. 

  396.   __f->__ptr  = __REINTERPRET_CAST(unsigned char*, __next);
    397. 

  397.   _bufend(__f) = __REINTERPRET_CAST(unsigned char*, __end);
    398. 

  398. }
    399. 

  399. 

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

  401. 

  402. # define _STLP_FILE_I_O_IDENTICAL
    403. 

  403. 

  404. #elif defined (__BORLANDC__)
    405. 

  405. 

  406. typedef unsigned char* _File_ptr_type;
    407. 

  407. 

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

  409. inline char* _FILE_I_begin(const FILE *__f) { return (char*) __f->buffer;
    410. 

  410. }
    411. 

  411. inline char* _FILE_I_next(const FILE *__f)
    412. 

  412. { return (char*)__f->curp; }
    413. 

  413. inline char* _FILE_I_end(const FILE *__f)
    414. 

  414. { return (char*) __f->curp + __f->level; }
    415. 

  415. 

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

  417. 

  418. inline char& _FILE_I_preincr(FILE *__f)
    419. 

  419. { --__f->level; return *(char*) (++__f->curp); }
    420. 

  420. inline char& _FILE_I_postincr(FILE *__f)
    421. 

  421. { --__f->level; return *(char*) (__f->curp++); }
    422. 

  422. inline char& _FILE_I_predecr(FILE *__f)
    423. 

  423. { ++__f->level; return *(char*) (--__f->curp); }
    424. 

  424. inline char& _FILE_I_postdecr(FILE *__f)
    425. 

  425. { ++__f->level; return *(char*) (__f->curp--); }
    426. 

  426. inline void _FILE_I_bump(FILE *__f, int __n)
    427. 

  427. { __f->curp += __n; __f->level -= __n; }
    428. 

  428. 

  429. inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
    430. 

  430.   __f->buffer = (_File_ptr_type) __begin;
    431. 

  431.   __f->curp = (_File_ptr_type) __next;
    432. 

  432.   __f->level = __end - __next;
    433. 

  433. }
    434. 

  434. 

  435. # define _STLP_FILE_I_O_IDENTICAL
    436. 

  436. 

  437. #elif defined( __MWERKS__ )
    438. 

  438. 

  439. // using MWERKS-specific defines here to detect other OS targets
    440. 

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

  441. // work for Win32 and WinCE
    442. 

  442. 

  443. #ifndef N_PLAT_NLM
    444. 

  444. // Hmm, at least for Novell NetWare __dest_os == __mac_os true too..
    445. 

  445. // May be both __dest_os and __mac_os defined and empty?   - ptr
    446. 

  446. # if __dest_os == __mac_os
    447. 

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

  448. # else
    449. 

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

  450. # endif // __dest_os == __mac_os
    451. 

  451. 

  452. //       Returns a pointer to the beginning of the buffer.
    453. 

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

  454. //       Returns the current read/write position within the buffer.
    455. 

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

  456. 

  457. //       Returns a pointer immediately past the end of the buffer.
    458. 

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

  459. 

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

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

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

  463. 

  464. //       Increments the current read/write position by 1, returning the
    465. 

  465. //       character at the old position.
    466. 

  466. inline char& _FILE_I_preincr(FILE *__f)
    467. 

  467.   { --__f->buffer_len; return *(char*) (++__f->buffer_ptr); }
    468. 

  468. inline char& _FILE_I_postincr(FILE *__f)
    469. 

  469.   { --__f->buffer_len; return *(char*) (__f->buffer_ptr++); }
    470. 

  470. inline char& _FILE_I_predecr(FILE *__f)
    471. 

  471.   { ++__f->buffer_len; return *(char*) (--__f->buffer_ptr); }
    472. 

  472. inline char& _FILE_I_postdecr(FILE *__f)
    473. 

  473.   { ++__f->buffer_len; return *(char*) (__f->buffer_ptr--); }
    474. 

  474. inline void  _FILE_I_bump(FILE *__f, int __n)
    475. 

  475.   { __f->buffer_ptr += __n; __f->buffer_len -= __n; }
    476. 

  476. 

  477. inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
    478. 

  478.   __f->buffer = __REINTERPRET_CAST(unsigned char*, __begin);
    479. 

  479.   __f->buffer_ptr   = __REINTERPRET_CAST(unsigned char*, __next);
    480. 

  480.   __f->buffer_len  = __end - __next;
    481. 

  481.   __f->buffer_size = __end - __begin;
    482. 

  482. }
    483. 

  483. #else // N_PLAT_NLM   - ptr
    484. 

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

  485. inline char* _FILE_I_begin(const FILE *__f) { return __REINTERPRET_CAST(char*, __f->_base); }
    486. 

  486. //       Returns the current read/write position within the buffer.
    487. 

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

  488. 

  489. //       Returns a pointer immediately past the end of the buffer.
    490. 

  490. inline char* _FILE_I_end(const FILE *__f) { return __REINTERPRET_CAST(char*, __f->_ptr + __f->_avail); }
    491. 

  491. 

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

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

  494. inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return __f->_avail; }
    495. 

  495. 

  496. //       Increments the current read/write position by 1, returning the
    497. 

  497. //       character at the old position.
    498. 

  498. inline char& _FILE_I_preincr(FILE *__f)
    499. 

  499.   { --__f->_avail; return *(char*) (++__f->_ptr); }
    500. 

  500. inline char& _FILE_I_postincr(FILE *__f)
    501. 

  501.   { --__f->_avail; return *(char*) (__f->_ptr++); }
    502. 

  502. inline char& _FILE_I_predecr(FILE *__f)
    503. 

  503.   { ++__f->_avail; return *(char*) (--__f->_ptr); }
    504. 

  504. inline char& _FILE_I_postdecr(FILE *__f)
    505. 

  505.   { ++__f->_avail; return *(char*) (__f->_ptr--); }
    506. 

  506. inline void  _FILE_I_bump(FILE *__f, int __n)
    507. 

  507.   { __f->_ptr += __n; __f->_avail -= __n; }
    508. 

  508. 

  509. inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
    510. 

  510.   __f->_base  = __REINTERPRET_CAST(unsigned char*, __begin);
    511. 

  511.   __f->_ptr   = __REINTERPRET_CAST(unsigned char*, __next);
    512. 

  512.   __f->_avail = __end - __next;
    513. 

  513. }
    514. 

  514. #endif // N_PLAT_NLM
    515. 

  515. 

  516. 

  517. # define _STLP_FILE_I_O_IDENTICAL
    518. 

  518. 

  519. #elif defined(__DMC__)
    520. 

  520. 

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

  522. 

  523. //       Returns a pointer to the beginning of the buffer.
    524. 

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

  525. 

  526. //       Returns the current read/write position within the buffer.
    527. 

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

  528. 

  529. //       Returns a pointer immediately past the end of the buffer.
    530. 

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

  531. 

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

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

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

  535. 

  536. //       Increments the current read/write position by 1, returning the
    537. 

  537. //       character at the NEW position.
    538. 

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

  539. 

  540. 

  541. //       Increments the current read/write position by 1, returning the
    542. 

  542. //       character at the old position.
    543. 

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

  544. 

  545. //       Decrements the current read/write position by 1, returning the
    546. 

  546. //       character at the NEW position.
    547. 

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

  548. 

  549. //       Decrements the current read/write position by 1, returning the
    550. 

  550. //       character at the old position.
    551. 

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

  552. 

  553. //       Increments the current read/write position by __n.
    554. 

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

  555. 

  556. //       Sets the beginning of the bufer to __begin, the current read/write
    557. 

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

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

  559. inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end)
    560. 

  560. {
    561. 

  561.   __f->_base = __begin;
    562. 

  562.   __f->_ptr = __next;
    563. 

  563.   __f->_cnt = __end - __next;
    564. 

  564.   __f->_bufsiz = __end - __begin;
    565. 

  565. }
    566. 

  566. 

  567. # define _STLP_FILE_I_O_IDENTICAL
    568. 

  568. 

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

  570. 

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

  572. 

  573. //       Returns a pointer to the beginning of the buffer.
    574. 

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

  575. 

  576. //       Returns the current read/write position within the buffer.
    577. 

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

  578. 

  579. //       Returns a pointer immediately past the end of the buffer.
    580. 

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

  581. 

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

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

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

  585. 

  586. //       Increments the current read/write position by 1, returning the
    587. 

  587. //       character at the NEW position.
    588. 

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

  589. 

  590. 

  591. //       Increments the current read/write position by 1, returning the
    592. 

  592. //       character at the old position.
    593. 

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

  594. 

  595. //       Decrements the current read/write position by 1, returning the
    596. 

  596. //       character at the NEW position.
    597. 

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

  598. 

  599. //       Decrements the current read/write position by 1, returning the
    600. 

  600. //       character at the old position.
    601. 

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

  602. 

  603. //       Increments the current read/write position by __n.
    604. 

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

  605. 

  606. //       Sets the beginning of the bufer to __begin, the current read/write
    607. 

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

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

  609. inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end)
    610. 

  610. {
    611. 

  611.   __f->_base = (unsigned char*)__begin;
    612. 

  612.   __f->_ptr  = (unsigned char*)__next;
    613. 

  613.   __f->_end  = (unsigned char*)__end;
    614. 

  614.   __f->_cnt  = __end - __next;
    615. 

  615.   __f->_size = __end - __begin;
    616. 

  616. }
    617. 

  617. 

  618. # define _STLP_FILE_I_O_IDENTICAL
    619. 

  619. 

  620. #elif defined (__MVS__)
    621. 

  621. 

  622. typedef unsigned char* _File_ptr_type;
    623. 

  623. 

  624. inline int _FILE_fd(const FILE *__f) { return fileno(__CONST_CAST(FILE
    625. 

  625.                   *,__f)); }
    626. 

  626. inline char* _FILE_I_begin(const FILE *__f) { return (char*)
    627. 

  627.             __f->__fp->__bufPtr; }
    628. 

  628. inline char* _FILE_I_next(const FILE *__f) { return (char*)
    629. 

  629.                  __f->__fp->__bufPtr; }
    630. 

  630. inline char* _FILE_I_end(const FILE *__f)
    631. 

  631. { return (char*) __f->__fp->__bufPtr + __f->__fp->__countIn; }
    632. 

  632. 

  633. inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return
    634. 

  634.                 __f->__fp->__countIn; }
    635. 

  635. 

  636. inline char& _FILE_I_preincr(FILE *__f)
    637. 

  637. { --__f->__fp->__countIn; return *(char*) (++__f->__fp->__bufPtr); }
    638. 

  638. inline char& _FILE_I_postincr(FILE *__f)
    639. 

  639. { --__f->__fp->__countIn; return *(char*) (__f->__fp->__bufPtr++); }
    640. 

  640. inline char& _FILE_I_predecr(FILE *__f)
    641. 

  641. { ++__f->__fp->__countIn; return *(char*) (--__f->__fp->__bufPtr); }
    642. 

  642. inline char& _FILE_I_postdecr(FILE *__f)
    643. 

  643. { ++__f->__fp->__countIn; return *(char*) (__f->__fp->__bufPtr--); }
    644. 

  644. inline void _FILE_I_bump(FILE *__f, int __n)
    645. 

  645. { __f->__fp->__bufPtr += __n; __f->__fp->__countIn -= __n; }
    646. 

  646. 

  647. inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char*
    648. 

  648.       __end) {
    649. 

  649.   // __f->_base = (_File_ptr_type) __begin;
    650. 

  650.   if(__f->__fp) {
    651. 

  651.     __f->__fp->__bufPtr = (_File_ptr_type) __next;
    652. 

  652.     __f->__fp->__countIn = __end - __next;
    653. 

  653.   }
    654. 

  654. }
    655. 

  655. 

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

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

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

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

  660. 

  661. inline char& _FILE_O_preincr(FILE *__f)
    662. 

  662. { --__f->__fp->__countOut; return *(char*) (++__f->__fp->__bufPtr); }
    663. 

  663. inline char& _FILE_O_postincr(FILE *__f)
    664. 

  664. { --__f->__fp->__countOut; return *(char*) (__f->__fp->__bufPtr++); }
    665. 

  665. inline char& _FILE_O_predecr(FILE *__f)
    666. 

  666. { ++__f->__fp->__countOut; return *(char*) (--__f->__fp->__bufPtr); }
    667. 

  667. inline char& _FILE_O_postdecr(FILE *__f)
    668. 

  668. { ++__f->__fp->__countOut; return *(char*) (__f->__fp->__bufPtr--); }
    669. 

  669. inline void _FILE_O_bump(FILE *__f, int __n)
    670. 

  670. { __f->__fp->__bufPtr += __n; __f->__fp->__countOut -= __n; }
    671. 

  671. 

  672. inline void _FILE_O_set(FILE *__f, char* __begin, char* __next, char*
    673. 

  673.       __end) {
    674. 

  674.   // __f->_base = (_File_ptr_type) __begin;
    675. 

  675.   if(__f->__fp) {
    676. 

  676.     __f->__fp->__bufPtr = (_File_ptr_type) __next;
    677. 

  677.     __f->__fp->__countOut = __end - __next;
    678. 

  678.   }
    679. 

  679. }
    680. 

  680. 

  681. #elif defined(__QNXNTO__)
    682. 

  682. 

  683. inline int _FILE_fd(const FILE *__f) { return __f->_handle;
    684. 

  684. }
    685. 

  685. inline char* _FILE_I_begin(const FILE *__f) { return
    686. 

  686.                                                 (char*) __f->_base; }
    687. 

  687. inline char* _FILE_I_next(const FILE *__f) { return
    688. 

  688.                                                (char*) __f->_ptr; }
    689. 

  689. inline char* _FILE_I_end(const FILE *__f)
    690. 

  690. { return (char*) __f->_ptr + __f->_cnt; }
    691. 

  691. 

  692. inline ptrdiff_t _FILE_I_avail(const FILE *__f) { return
    693. 

  693.                                                     __f->_cnt; }
    694. 

  694. 

  695. inline char& _FILE_I_preincr(FILE *__f)
    696. 

  696. { --__f->_cnt; return *(char*) (++__f->_ptr); }
    697. 

  697. inline char& _FILE_I_postincr(FILE *__f)
    698. 

  698. { --__f->_cnt; return *(char*) (__f->_ptr++); }
    699. 

  699. inline char& _FILE_I_predecr(FILE *__f)
    700. 

  700. { ++__f->_cnt; return *(char*) (--__f->_ptr); }
    701. 

  701. inline char& _FILE_I_postdecr(FILE *__f)
    702. 

  702. { ++__f->_cnt; return *(char*) (__f->_ptr--); }
    703. 

  703. inline void _FILE_I_bump(FILE *__f, int __n)
    704. 

  704. { __f->_ptr += __n; __f->_cnt -= __n; }
    705. 

  705. 

  706. inline void _FILE_I_set(FILE *__f, char* __begin, char*
    707. 

  707.                         __next, char*
    708. 

  708.                         __end) {
    709. 

  709.   __f->_base = (unsigned char*) __begin;
    710. 

  710.   __f->_ptr = (unsigned char*) __next;
    711. 

  711.   __f->_cnt = __end - __next;
    712. 

  712. }
    713. 

  713. 

  714. # define _STLP_FILE_I_O_IDENTICAL
    715. 

  715. 

  716. #elif defined(__WATCOMC__)                   // Nikolaev
    717. 

  717. 

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

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

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

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

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

  723. 

  724. inline char& _FILE_I_preincr(FILE *__f)
    725. 

  725. {
    726. 

  726.   --__f->_cnt;
    727. 

  727.   return *__REINTERPRET_CAST(char*, ++__f->_ptr);
    728. 

  728. }
    729. 

  729. 

  730. inline char& _FILE_I_postincr(FILE *__f)
    731. 

  731. {
    732. 

  732.   --__f->_cnt;
    733. 

  733.   return *__REINTERPRET_CAST(char*, __f->_ptr++);
    734. 

  734. }
    735. 

  735. 

  736. inline char& _FILE_I_predecr(FILE *__f)
    737. 

  737. {
    738. 

  738.   ++__f->_cnt;
    739. 

  739.   return *__REINTERPRET_CAST(char*, --__f->_ptr);
    740. 

  740. }
    741. 

  741. 

  742. inline char& _FILE_I_postdecr(FILE *__f)
    743. 

  743. {
    744. 

  744.   ++__f->_cnt;
    745. 

  745.   return *__REINTERPRET_CAST(char*, __f->_ptr--);
    746. 

  746. }
    747. 

  747. 

  748. inline void _FILE_I_bump(FILE *__f, int __n)
    749. 

  749. {
    750. 

  750.   __f->_ptr += __n;
    751. 

  751.   __f->_cnt -= __n;
    752. 

  752. }
    753. 

  753. 

  754. inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end)
    755. 

  755. {
    756. 

  756.   __f->_link = __REINTERPRET_CAST(__stream_link*, __begin);
    757. 

  757.   __f->_ptr  = __REINTERPRET_CAST(unsigned char*, __next);
    758. 

  758.   __f->_cnt  = __end - __next;
    759. 

  759. }
    760. 

  760. 

  761. # define _STLP_FILE_I_O_IDENTICAL
    762. 

  762. 

  763. #elif defined (__Lynx__)
    764. 

  764. 

  765. // the prototypes are taken from LynxOS patch for STLport 4.0
    766. 

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

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

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

  769. inline char* _FILE_I_end(const FILE *__f)
    770. 

  770.   { return (char*) __f->_ptr + __f->_cnt; }
    771. 

  771. 

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

  773. 

  774. inline char& _FILE_I_preincr(FILE *__f)
    775. 

  775.   { --__f->_cnt; return *(char*) (++__f->_ptr); }
    776. 

  776. inline char& _FILE_I_postincr(FILE *__f)
    777. 

  777.   { --__f->_cnt; return *(char*) (__f->_ptr++); }
    778. 

  778. inline char& _FILE_I_predecr(FILE *__f)
    779. 

  779.    { ++__f->_cnt; return *(char*) (--__f->_ptr); }
    780. 

  780. inline char& _FILE_I_postdecr(FILE *__f)
    781. 

  781.   { ++__f->_cnt; return *(char*) (__f->_ptr--); }
    782. 

  782. inline void  _FILE_I_bump(FILE *__f, int __n)
    783. 

  783.   { __f->_ptr += __n; __f->_cnt -= __n; }
    784. 

  784. 

  785. inline void _FILE_I_set(FILE *__f, char* __begin, char* __next, char* __end) {
    786. 

  786.   __f->_base = __begin;
    787. 

  787.   __f->_ptr  = __next;
    788. 

  788.   __f->_cnt  = __end - __next;
    789. 

  789. }
    790. 

  790. # define _STLP_FILE_I_O_IDENTICAL
    791. 

  791. 

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

  793. 

  794. # error The C++ I/O library is not configured for this compiler
    795. 

  795. 

  796. #endif
    797. 

  797. 

  798. 

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

  800. # ifdef _STLP_FILE_I_O_IDENTICAL
    801. 

  801. inline char* _FILE_O_begin(const FILE *__f) { return _FILE_I_begin(__f); }
    802. 

  802. inline char* _FILE_O_next(const FILE *__f)  { return _FILE_I_next(__f); }
    803. 

  803. inline char* _FILE_O_end(const FILE *__f)   { return _FILE_I_end(__f); }
    804. 

  804. 

  805. inline ptrdiff_t _FILE_O_avail(const FILE *__f) { return _FILE_I_avail(__f); }
    806. 

  806. 

  807. inline char& _FILE_O_preincr(FILE *__f)  { return _FILE_I_preincr(__f); }
    808. 

  808. inline char& _FILE_O_postincr(FILE *__f) { return _FILE_I_postincr(__f); }
    809. 

  809. inline char& _FILE_O_predecr(FILE *__f)  { return _FILE_I_predecr(__f); }
    810. 

  810. inline char& _FILE_O_postdecr(FILE *__f) { return _FILE_I_postdecr(__f); }
    811. 

  811. 

  812. inline void  _FILE_O_bump(FILE *__f, int __n) { _FILE_I_bump(__f, __n); }
    813. 

  813. inline void _FILE_O_set(FILE *__f, char* __begin, char* __next, char* __end)
    814. 

  814.   { _FILE_I_set(__f, __begin, __next, __end); }
    815. 

  815. # endif
    816. 

  816. 

  817. _STLP_END_NAMESPACE
    818. 

  818. 

  819. #endif /* _STLP_STDIO_FILE_H */
    820. 

  820. 

  821. // Local Variables:
    822. 

  822. // mode:C++
    823. 

  823. // End:
    824.