![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stream.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / cfront / libC / stream|
Return to stream.h CVS log | Up to [Research Unix] / researchv8dc / cmd / cfront / libC / stream |
1.1 root 1: /*
2: stream.h, the header file for the C++ stream i/o system 4/06/85
3: */
4: #include <stdio.h>
5: #ifndef NULL
6: #define NULL 0
7: #endif
8: #ifndef EOF
9: #define EOF (-1)
10: #endif
11: #ifndef BUFSIZE
12: #define BUFSIZE 1024
13: #endif
14:
15: #ifndef STREAMH
16: #define STREAMH
17: enum state_value { _good=0, _eof=1, _fail=2, _bad=4 };
18: enum open_mode { input=0, output=1, append=2 };
19:
20: struct streambuf { // a buffer for streams
21:
22: char* base; // pointer to beginning of buffer
23: char* pptr; // pointer to next free byte
24: char* gptr; // pointer to next filled byte
25: char* eptr; // pointer to first byte following buffer
26: char alloc; // true if buffer is allocated using "new"
27:
28: virtual overflow(int c=EOF); // Empty a buffer.
29: // Return EOF on error
30: // 0 on success
31:
32: virtual int underflow(); // Fill a buffer
33: // Return EOF on error or end of input
34: // next character on success
35:
36:
37: inline int sgetc() // get the current character
38: {
39: return (gptr==pptr) ? underflow() : *gptr&0377;
40: }
41:
42:
43: inline int snextc() // get the next character
44: {
45: return ((++gptr)==pptr) ? underflow() : *gptr&0377;
46: }
47:
48:
49: inline void sputbackc(char c)
50: /*
51: Return a character to the buffer (ala lookahead 1). Since
52: the user may be "playing games" the character might be
53: different than the last one returned by sgetc or snextc.
54: If the user attempts to put back more characters than have
55: been extracted, nothing will be put back.
56: Putting back an EOF is DANGEROUS.
57: */
58: {
59: if (gptr >= base) *--gptr = c;
60: }
61:
62: inline int sputc(int c =EOF) // put a character into the buffer
63: {
64: return (eptr<=pptr) ? overflow(c&0377) : (*pptr++=c&0377);
65: }
66:
67:
68: inline streambuf * setbuf(char *p, int len, int count =0)
69: /*
70: supply an area for a buffer.
71: The "count" parameter allows the buffer to start in non-empty.
72: */
73: {
74: base = gptr = p;
75: pptr = p + count;
76: eptr = base + len;
77: return this;
78: }
79:
80: int allocate(); // allocate some space for the buffer
81:
82: streambuf() { base = gptr = pptr = eptr = NULL; alloc = 0; }
83: streambuf(char* p, int l) { setbuf(p,l); alloc = 0; }
84: ~streambuf() { if (base != NULL && alloc) delete base; }
85: };
86:
87: extern int close(int);
88:
89: struct filebuf : public streambuf { // a stream buffer for files
90:
91: int fd; // file descriptor
92: char opened; // non-zero if file has been opened
93:
94: int overflow(int c=EOF); // Empty a buffer.
95: // Return EOF on error
96: // 0 on success
97:
98: int underflow(); // Fill a buffer.
99: // Return EOF on error or end of input
100: // next character on success
101:
102: filebuf* open(char *name, open_mode om); // Open a file
103: // return 0 if failure
104: // return "this" if success
105: int close() { int i = opened?::close(fd):0; opened=0; return i; }
106:
107: filebuf() { opened = 0; }
108: filebuf(int nfd) { fd = nfd; opened = 1; }
109: filebuf(int nfd, char* p, int l) : (p,l) { fd = nfd; opened = 1; }
110: ~filebuf() { close(); }
111: };
112:
113: struct circbuf : public streambuf { // a circular stream buffer
114:
115: int overflow(int c=EOF); // Empty a buffer.
116: // Return EOF on error
117: // 0 on success
118:
119: int underflow(); // Fill a buffer.
120: // Return EOF on error or end of input
121: // next character on success
122: circbuf() { }
123: ~circbuf() { }
124:
125: };
126:
127: /*
128: * This type defines white space. Any number of whitespace
129: * characters can be used to separate two fields in an input
130: * stream. The effect of sending an input stream to a whitespace
131: * object is to cause all whitespace in the input stream, up to the
132: * next non-whitespace character, to be discarded. The whitespace
133: * characters are space, tab, form feed, and new line.
134: */
135: struct whitespace { };
136:
137: /***************************** output: *********************************/
138:
139: extern char* oct(long, int =0);
140: extern char* dec(long, int =0);
141: extern char* hex(long, int =0);
142:
143: extern char* chr(int, int =0); // chr(0) is the empty string ""
144: extern char* str(char*, int =0);
145: extern char* form(char* ...); // printf format
146:
147: class istream;
148: class common;
149:
150: class ostream {
151: friend istream;
152:
153: streambuf* bp;
154: short state;
155: public:
156: ostream& operator<<(char*); // write string
157: ostream& operator<<(int a) { return *this<<long(a); }
158: ostream& operator<<(long); // beware: << 'a' writes 97
159: ostream& operator<<(double);
160: ostream& operator<<(streambuf&);
161: ostream& operator<<(whitespace&);
162: ostream& operator<<(common&);
163:
164: ostream& put(char); // put('a') writes a
165: ostream& flush() { bp->overflow(); return *this; }
166:
167:
168: operator void*(){ return _eof<state?0:this; }
169: int operator!() { return _eof<state; }
170: int eof() { return state&_eof; }
171: int fail() { return _eof<state; }
172: int bad() { return _fail<state; }
173: int good() { return state==_good; }
174: void clear(state_value i =0) { state=i; }
175: int rdstate() { return state; }
176: char* bufptr() { return bp->base; }
177:
178: ostream(streambuf* s) { bp = s; state = 0; }
179: ostream(int fd) { bp = new filebuf(fd); state = 0; }
180: ostream(int size, char* p)
181: {
182: state = 0;
183: bp = new streambuf();
184: if (p == 0) p = new char[size];
185: bp->setbuf(p, size);
186: }
187: ~ostream() { flush(); }
188: };
189:
190: /***************************** input: ***********************************/
191:
192: /*
193: The >> operator reads after skipping initial whitespace
194: get() reads but does not skip whitespace
195:
196: if >> fails (1) the state of the stream turns non-zero
197: (2) the value of the argument does not change
198: (3) non-whitespace characters are put back onto the stream
199:
200: >> get() fails if the state of the stream is non-zero
201: */
202:
203: class istream {
204: friend ostream;
205:
206: streambuf* bp;
207: ostream* tied_to;
208: char skipws; // if non-null, automaticly skip whitespace
209: short state;
210:
211: friend void eatwhite (istream&);
212: public:
213: int skip(int i) { int ii=skipws; skipws=i; return ii; }
214:
215: /*
216: formatted input: >> skip whitespace
217: */
218: istream& operator>>(char*); // string
219: istream& operator>>(char&); // single character
220: istream& operator>>(short&);
221: istream& operator>>(int&);
222: istream& operator>>(long&);
223: istream& operator>>(float&);
224: istream& operator>>(double&);
225: istream& operator>>(streambuf&);
226: istream& operator>>(whitespace&); // skip whitespace
227: istream& operator>>(common&);
228:
229: /*
230: raw input: get's do not skip whitespace
231: */
232: istream& get(char*, int, char ='\n'); // string
233: istream& get(streambuf& sb, char ='\n');
234: istream& get(char& c) // single character
235: {
236: int os = skip(0);
237: *this >> c;
238: skip(os);
239: return *this;
240: }
241:
242: istream& putback(char c);
243: ostream* tie(ostream& s) { ostream* t = tied_to; tied_to = &s; return t; }
244:
245: operator void*(){ return _eof<state?0:this; }
246: int operator!() { return _eof<state; }
247: int eof() { return state&_eof; }
248: int fail() { return _eof<state; }
249: int bad() { return _fail<state; }
250: int good() { return state==_good; }
251: void clear(state_value i =0) { state=i; }
252: int rdstate() { return state; }
253: char* bufptr() { return bp->base; }
254:
255: istream(streambuf* s, int sk =1, ostream* t =0) // bind to buffer
256: {
257: state = 0;
258: skipws = sk;
259: tied_to = t;
260: bp = s;
261: }
262:
263: istream(int size, char* p, int sk =1) // bind to string
264: {
265: state = 0;
266: skipws = sk;
267: tied_to = 0;
268: bp = new streambuf();
269: if (p == 0) p = new char[size];
270: bp->setbuf(p, size, size);
271: }
272:
273: istream(int fd, int sk =1, ostream* t =0) // bind to file
274: {
275: state = 0;
276: skipws = sk;
277: tied_to = t;
278: bp = new filebuf(fd);
279: }
280: };
281:
282:
283: extern istream cin; // standard input predefined
284: extern ostream cout; // standard output
285: extern ostream cerr; // error output
286:
287: extern whitespace WS; // predefined white space
288:
289: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.