1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
|
/***
*ios.h - definitions/declarations for the ios class.
*
* Copyright (c) 1990-1993, Microsoft Corporation. All rights reserved.
*
*Purpose:
* This file defines the classes, values, macros, and functions
* used by the ios class.
* [AT&T C++]
*
*Revision History:
* 01-23-92 KRS Ported from 16-bit version.
* 03-02-92 KRS Added locks for multithread support.
* 06-03-92 KRS Add NULL definition here too, for convenience.
* 08-27-92 KRS Removed bogus 'short' defs from private section.
* 02-23-93 SKS Update copyright to 1993
* 03-23-93 CFW Modified #pragma warnings.
*
****/
#ifndef _INC_IOS
#define _INC_IOS
#ifndef _INTERNAL_IFSTRIP_
#ifdef COMBOINC
#if defined(_DLL) && !defined(MTHREAD)
#error Cannot define _DLL without MTHREAD
#endif
#endif
#endif /* !_INTERNAL_IFSTRIP_ */
#ifdef MTHREAD
#ifndef _INTERNAL_IFSTRIP_
// CONSIDER: change implementation so crit. sect. not exposed
#include <oscalls.h> // critical section declarations
#else /* !_INTERNAL_IFSTRIP_ */
#include <windows.h> // critical section declarations
#endif /* !_INTERNAL_IFSTRIP_ */
extern "C" {
void _mtlockinit(PRTL_CRITICAL_SECTION);
void _mtlock(PRTL_CRITICAL_SECTION);
void _mtunlock(PRTL_CRITICAL_SECTION);
}
#endif
#ifndef NULL
#define NULL 0
#endif
#ifndef EOF
#define EOF (-1)
#endif
// C4505: "unreferenced local function has been removed"
#pragma warning(disable:4505) // disable C4505 warning
// #pragma warning(default:4505) // use this to reenable, if desired
// C4103 : "used #pragma pack to change alignment"
#pragma warning(disable:4103) // disable C4103 warning
// #pragma warning(default:4103) // use this to reenable, if desired
// Force word packing to avoid possible -Zp override
#pragma pack(4)
class streambuf;
class ostream;
class ios {
public:
enum io_state { goodbit = 0x00,
eofbit = 0x01,
failbit = 0x02,
badbit = 0x04 };
enum open_mode { in = 0x01,
out = 0x02,
ate = 0x04,
app = 0x08,
trunc = 0x10,
nocreate = 0x20,
noreplace = 0x40,
binary = 0x80 }; // CONSIDER: not in latest spec.
enum seek_dir { beg=0, cur=1, end=2 };
enum { skipws = 0x0001,
left = 0x0002,
right = 0x0004,
internal = 0x0008,
dec = 0x0010,
oct = 0x0020,
hex = 0x0040,
showbase = 0x0080,
showpoint = 0x0100,
uppercase = 0x0200,
showpos = 0x0400,
scientific = 0x0800,
fixed = 0x1000,
unitbuf = 0x2000,
stdio = 0x4000
};
static const long basefield; // dec | oct | hex
static const long adjustfield; // left | right | internal
static const long floatfield; // scientific | fixed
ios(streambuf*); // differs from ANSI
virtual ~ios();
inline long flags() const;
inline long flags(long _l);
inline long setf(long _f,long _m);
inline long setf(long _l);
inline long unsetf(long _l);
inline int width() const;
inline int width(int _i);
inline ostream* tie(ostream* _os);
inline ostream* tie() const;
inline char fill() const;
inline char fill(char _c);
inline int precision(int _i);
inline int precision() const;
inline int rdstate() const;
inline void clear(int _i = 0);
// inline operator void*() const;
operator void *() const { if(state&(badbit|failbit) ) return 0; return (void *)this; }
inline int operator!() const;
inline int good() const;
inline int eof() const;
inline int fail() const;
inline int bad() const;
inline streambuf* rdbuf() const;
inline long & iword(int) const;
inline void * & pword(int) const;
static long bitalloc();
static int xalloc();
static void sync_with_stdio();
#ifdef MTHREAD
inline void setlock();
inline void clrlock();
void lock() { if (LockFlg<0) _mtlock(lockptr()); };
void unlock() { if (LockFlg<0) _mtunlock(lockptr()); }
inline void lockbuf();
inline void unlockbuf();
#else
void lock() { }
void unlock() { }
void lockbuf() { }
void unlockbuf() { }
#endif
protected:
ios();
ios(const ios&); // treat as private
ios& operator=(const ios&);
void init(streambuf*);
enum { skipping, tied };
streambuf* bp;
int state;
int ispecial; // not used
int ospecial; // not used
int isfx_special; // not used
int osfx_special; // not used
int x_delbuf; // if set, rdbuf() deleted by ~ios
ostream* x_tie;
long x_flags;
int x_precision;
char x_fill;
int x_width;
static void (*stdioflush)(); // not used
#ifdef MTHREAD
static void lockc() { _mtlock(& x_lockc); }
static void unlockc() { _mtunlock( & x_lockc); }
PRTL_CRITICAL_SECTION lockptr() { return & x_lock; }
#else
static void lockc() { }
static void unlockc() { }
#endif
public:
int delbuf() const { return x_delbuf; }
void delbuf(int _i) { x_delbuf = _i; }
private:
static long x_maxbit;
static int x_curindex;
// consider: make interal static to ios::sync_with_stdio()
static int sunk_with_stdio; // make sure sync_with done only once
#ifdef MTHREAD
#define MAXINDEX 7
static long x_statebuf[MAXINDEX+1]; // used by xalloc()
static int fLockcInit; // used to see if x_lockc initialized
static RTL_CRITICAL_SECTION x_lockc; // used to lock static (class) data members
// consider: make pointer and allocate elsewhere
int LockFlg; // enable locking flag
RTL_CRITICAL_SECTION x_lock; // used for multi-thread lock on object
#else
static long * x_statebuf; // used by xalloc()
#endif
};
#include <streamb.h>
inline ios& dec(ios& _strm) { _strm.setf(ios::dec,ios::basefield); return _strm; }
inline ios& hex(ios& _strm) { _strm.setf(ios::hex,ios::basefield); return _strm; }
inline ios& oct(ios& _strm) { _strm.setf(ios::oct,ios::basefield); return _strm; }
inline long ios::flags() const { return x_flags; }
inline long ios::flags(long _l){ long _lO; _lO = x_flags; x_flags = _l; return _lO; }
inline long ios::setf(long _l,long _m){ long _lO; lock(); _lO = x_flags; x_flags = (_l&_m) | (x_flags&(~_m)); unlock(); return _lO; }
inline long ios::setf(long _l){ long _lO; lock(); _lO = x_flags; x_flags |= _l; unlock(); return _lO; }
inline long ios::unsetf(long _l){ long _lO; lock(); _lO = x_flags; x_flags &= (~_l); unlock(); return _lO; }
inline int ios::width() const { return x_width; }
inline int ios::width(int _i){ int _iO; _iO = (int)x_width; x_width = _i; return _iO; }
inline ostream* ios::tie(ostream* _os){ ostream* _osO; _osO = x_tie; x_tie = _os; return _osO; }
inline ostream* ios::tie() const { return x_tie; }
inline char ios::fill() const { return x_fill; }
inline char ios::fill(char _c){ char _cO; _cO = x_fill; x_fill = _c; return _cO; }
inline int ios::precision(int _i){ int _iO; _iO = (int)x_precision; x_precision = _i; return _iO; }
inline int ios::precision() const { return x_precision; }
inline int ios::rdstate() const { return state; }
// inline ios::operator void *() const { if(state&(badbit|failbit) ) return 0; return (void *)this; }
inline int ios::operator!() const { return state&(badbit|failbit); }
inline int ios::bad() const { return state & badbit; }
// consider: are locks needed on clear() ?
inline void ios::clear(int _i){ lock(); state = _i; unlock(); }
inline int ios::eof() const { return state & eofbit; }
inline int ios::fail() const { return state & (badbit | failbit); }
inline int ios::good() const { return state == 0; }
inline streambuf* ios::rdbuf() const { return bp; }
inline long & ios::iword(int _i) const { return x_statebuf[_i] ; }
inline void * & ios::pword(int _i) const { return (void * &)x_statebuf[_i]; }
#ifdef MTHREAD
inline void ios::setlock() { LockFlg--; if (bp) bp->setlock(); }
inline void ios::clrlock() { if (LockFlg <= 0) LockFlg++; if (bp) bp->clrlock(); }
inline void ios::lockbuf() { bp->lock(); }
inline void ios::unlockbuf() { bp->unlock(); }
#endif
// Restore default packing
#pragma pack()
#endif // !_INC_IOS
|
