![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to in.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / cfront / libC / stream|
Return to in.c CVS log | Up to [Research Unix] / researchv9 / cmd / cfront / libC / stream |
1.1 root 1: /*
2: C++ stream i/o source
3:
4: in.c
5: */
6: #include <ctype.h>
7: #include "stream.h"
8: #include <common.h>
9:
10: filebuf cin_file(stdin); // UNIX input stream 0
11: istream cin(&cin_file,1,&cout); // cin tied to cout
12:
13: /* predefined whitespace */
14: whitespace WS;
15:
16: /*inline */void eatwhite (istream& is)
17: {
18: if (is.tied_to) is.tied_to->flush();
19: register streambuf *nbp = is.bp;
20: register char c = nbp->sgetc();
21: while (isspace(c)) c = nbp->snextc();
22: if (c == EOF) is.state |= _eof;
23: }
24:
25: istream& istream::operator>>(whitespace&)
26: {
27: register streambuf *nbp = bp;
28:
29: if (state) return *this;
30: if (tied_to) tied_to->flush();
31: register c = nbp->sgetc();
32: while (isspace(c)) c = nbp->snextc();
33: if (c == EOF) state |= _eof;
34: return *this;
35: }
36:
37: istream& istream::operator>>(register char& s)
38: /*
39: reads characters NOT very small integers
40: */
41: {
42: if (skipws)
43: eatwhite(*this);
44: else if (tied_to)
45: tied_to->flush();
46:
47: if (state) {
48: state |= _fail;
49: return *this;
50: }
51:
52: register c = bp->sgetc();
53: if (c == EOF) {
54: state |= _fail|_eof;
55: } else {
56: s = c;
57: bp->stossc();
58: }
59:
60: return *this;
61: }
62:
63: istream& istream::operator>>(register char* s)
64: {
65: register streambuf *nbp = bp;
66:
67:
68: if (skipws)
69: eatwhite(*this);
70: else if (tied_to)
71: tied_to->flush();
72:
73:
74: if (state) {
75: state |= _fail;
76: return *this;
77: }
78:
79: /* get string */
80: register c = nbp->sgetc();
81: if (c == EOF) state |= _fail;
82: while (!isspace(c) && c != EOF) {
83: *s++ = c;
84: c = nbp->snextc();
85: }
86: *s = '\0';
87:
88: if (c == EOF) state |= _eof;
89:
90: return *this;
91: }
92:
93: istream& istream::operator>>(long& i)
94: {
95: register c;
96: register ii = 0;
97: register streambuf *nbp = bp;
98: int neg = 0;
99:
100: if (skipws)
101: eatwhite(*this);
102: else if (tied_to)
103: tied_to->flush();
104:
105:
106: if (state) {
107: state |= _fail;
108: return *this;
109: }
110:
111: switch (c = nbp->sgetc()) {
112: case '-':
113: case '+':
114: neg = c;
115: c = nbp->snextc();
116: break;
117: case EOF:
118: state |= _fail;
119: }
120:
121: if (isdigit(c)) {
122: do {
123: ii = ii*10+c-'0';
124: } while (isdigit(c=nbp->snextc()));
125: i = (neg=='-') ? -ii : ii;
126: } else
127: state |= _fail;
128:
129: if (c == EOF) state |= _eof;
130: return *this;
131: }
132:
133: istream& istream::operator>>(int& i)
134: {
135: long l;
136:
137:
138: if (skipws)
139: eatwhite(*this);
140: else if (tied_to)
141: tied_to->flush();
142:
143: if (state) {
144: state |= _fail;
145: return *this;
146: }
147:
148: if ( *this>>l ) {
149: i = l;
150: }
151: return *this;
152: }
153:
154: istream& istream::operator>>(short& i)
155: {
156: long l;
157:
158: if (skipws)
159: eatwhite(*this);
160: else if (tied_to)
161: tied_to->flush();
162:
163:
164: if (state) {
165: state |= _fail;
166: return *this;
167: }
168:
169: if ( *this>>l ) {
170: i = l;
171: }
172: return *this;
173: }
174:
175: istream& istream::operator>>(double& d)
176: /*
177: {+|-} d* {.} d* { e|E {+|-} d+ }
178: except that
179: - a dot must be pre- or succeded by at least one digit
180: - an exponent must be preseded by at least one digit
181: */
182: {
183: register c = 0;
184: char buf[256];
185: register char* p = buf;
186: register streambuf* nbp = bp;
187:
188: if (skipws)
189: eatwhite(*this);
190: else if (tied_to)
191: tied_to->flush();
192:
193: if (state) {
194: state |= _fail;
195: return *this;
196: }
197:
198: /* get the sign */
199: switch (c = nbp->sgetc()) {
200: case EOF:
201: state = _eof|_fail;
202: return *this;
203: case '-':
204: case '+':
205: *p++ = c;
206: c = bp->snextc();
207: }
208:
209: /* get integral part */
210: while (isdigit(c)) {
211: *p++ = c;
212: c = bp->snextc();
213: }
214:
215: /* get fraction */
216: if (c == '.') {
217: do {
218: *p++ = c;
219: c = bp->snextc();
220: } while (isdigit(c));
221: }
222:
223: /* get exponent */
224: if (c == 'e' || c == 'E') {
225: *p++ = c;
226: switch (c = nbp->snextc()) {
227: case EOF:
228: state = _eof|_fail;
229: return *this;
230: case '-':
231: case '+':
232: *p++ = c;
233: c = bp->snextc();
234: }
235: while (isdigit(c)) {
236: *p++ = c;
237: c = bp->snextc();
238: }
239: }
240:
241: *p = 0;
242: d = atof(buf);
243:
244: if (c == EOF) state |= _eof;
245: return *this;
246: }
247:
248: istream& istream::operator>>(float& f)
249: {
250: double d;
251:
252:
253: if (skipws)
254: eatwhite(*this);
255: else if (tied_to)
256: tied_to->flush();
257:
258: if (state) {
259: state |= _fail;
260: return *this;
261: }
262:
263: if ( *this>>d ) {
264: f = d;
265: }
266: return *this;
267: }
268:
269: istream& istream::get(
270: register char* s, /* character array to read into */
271: register int len, /* size of character array */
272: register char term /* character that terminates input */
273: ) {
274: register c;
275: register streambuf *nbp = bp;
276:
277: if (tied_to) tied_to->flush();
278:
279: if (state) {
280: state |= _fail;
281: return *this;
282: }
283:
284: if ((c = bp->sgetc()) == EOF) {
285: state |= _fail | _eof;
286: return *this;
287: }
288:
289: while (c != term && c != EOF && len > 1) {
290: *s++ = c;
291: c = nbp->snextc();
292: len--;
293: }
294: *s = '\0';
295: if (c == EOF) state |= _eof;
296: return *this;
297: }
298:
299: istream& istream::putback(register char c)
300: {
301: bp->sputbackc(c);
302: return *this;
303: }
304:
305:
306: istream& istream::get(
307: register streambuf &s, /* streambuf to input to */
308: register char term /* termination character */
309: ){
310: register c;
311: register streambuf *nbp = bp;
312:
313: if (tied_to) tied_to->flush();
314:
315: if (state) {
316: state |= _fail;
317: return *this;
318: }
319:
320: if ((c = bp->sgetc()) == EOF) {
321: state |= _fail | _eof;
322: return *this;
323: }
324:
325: while (c != term && c != EOF) {
326: if (s.sputc(c) == EOF) break;
327: c = nbp->snextc();
328: }
329: if (c == EOF) state |= _eof;
330: return *this;
331: }
332:
333: istream& istream::operator>>(register streambuf &s) {
334: register c;
335: register streambuf *nbp = bp;
336:
337: if (tied_to) tied_to->flush();
338:
339: if (state) {
340: state |= _fail;
341: return *this;
342: }
343:
344: if ((c = bp->sgetc()) == EOF) {
345: state |= _fail | _eof;
346: return *this;
347: }
348:
349: while (c != EOF) {
350: if (s.sputc(c) == EOF) break;
351: c = nbp->snextc();
352: }
353: if (c == EOF) state |= _eof;
354: return *this;
355: }
356:
357: istream& istream::operator>>(common& p)
358: {
359: if (skipws)
360: eatwhite(*this);
361: else if (tied_to)
362: tied_to->flush();
363:
364: return p.read(*this);
365: }
366:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.