![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to iostream.cc CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / libg++ / libio|
Return to iostream.cc CVS log | Up to [Apple XNU] / GNUtools / libg++ / libio |
1.1 root 1: /* This is part of libio/iostream, providing -*- C++ -*- input/output.
2: Copyright (C) 1993 Free Software Foundation
3:
4: This file is part of the GNU IO Library. This library is free
5: software; you can redistribute it and/or modify it under the
6: terms of the GNU General Public License as published by the
7: Free Software Foundation; either version 2, or (at your option)
8: any later version.
9:
10: This library is distributed in the hope that it will be useful,
11: but WITHOUT ANY WARRANTY; without even the implied warranty of
12: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13: GNU General Public License for more details.
14:
15: You should have received a copy of the GNU General Public License
16: along with GNU CC; see the file COPYING. If not, write to
17: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
18:
19: As a special exception, if you link this library with files
20: compiled with a GNU compiler to produce an executable, this does not cause
21: the resulting executable to be covered by the GNU General Public License.
22: This exception does not however invalidate any other reasons why
23: the executable file might be covered by the GNU General Public License. */
24:
25: /* Written by Per Bothner ([email protected]). */
26:
27: #ifdef __GNUC__
28: #pragma implementation
29: #endif
30: #define _STREAM_COMPAT
31: #include <iostream.h>
32: #include "libioP.h"
33: extern "C" {
34: #include <stdio.h> /* Needed for sprintf */
35: }
36: extern "C" {
37: #include <ctype.h>
38: }
39: extern "C" {
40: #include <string.h>
41: }
42: extern "C" {
43: #include <limits.h>
44: }
45: #include "floatio.h"
46:
47: #define BUF (MAXEXP+MAXFRACT+1) /* + decimal point */
48:
49: //#define isspace(ch) ((ch)==' ' || (ch)=='\t' || (ch)=='\n')
50:
51: istream::istream(streambuf *sb, ostream* tied) : ios(sb, tied)
52: {
53: _flags |= ios::dont_close;
54: _gcount = 0;
55: }
56:
57: int skip_ws(streambuf* sb)
58: {
59: int ch;
60: for (;;) {
61: ch = sb->sbumpc();
62: if (ch == EOF || !isspace(ch))
63: return ch;
64: }
65: }
66:
67: istream& istream::get(char& c)
68: {
69: if (ipfx1()) {
70: int ch = _strbuf->sbumpc();
71: if (ch == EOF) {
72: set(ios::eofbit|ios::failbit);
73: _gcount = 0;
74: }
75: else {
76: c = (char)ch;
77: _gcount = 1;
78: }
79: }
80: return *this;
81: }
82:
83: int istream::peek()
84: {
85: if (!good())
86: return EOF;
87: if (_tie && rdbuf()->in_avail() == 0)
88: _tie->flush();
89: int ch = _strbuf->sgetc();
90: if (ch == EOF)
91: set(ios::eofbit);
92: return ch;
93: }
94:
95: istream& istream::ignore(int n /* = 1 */, int delim /* = EOF */)
96: {
97: if (ipfx1()) {
98: register streambuf* sb = _strbuf;
99: if (delim == EOF) {
100: _gcount = sb->ignore(n);
101: return *this;
102: }
103: _gcount = 0;
104: for (;;) {
105: #if 0
106: if (n != MAXINT) // FIXME
107: #endif
108: if (--n < 0)
109: break;
110: int ch = sb->sbumpc();
111: if (ch == EOF) {
112: set(ios::eofbit|ios::failbit);
113: break;
114: }
115: _gcount++;
116: if (ch == delim)
117: break;
118: }
119: }
120: return *this;
121: }
122:
123: istream& istream::read(char *s, int n)
124: {
125: if (ipfx1()) {
126: _gcount = _strbuf->sgetn(s, n);
127: if (_gcount != n)
128: set(ios::failbit);
129: }
130: return *this;
131: }
132:
133: istream& istream::seekg(streampos pos)
134: {
135: pos = _strbuf->sseekpos(pos, ios::in);
136: if (pos == streampos(EOF))
137: set(ios::badbit);
138: return *this;
139: }
140:
141: istream& istream::seekg(streamoff off, _seek_dir dir)
142: {
143: streampos pos
144: = _IO_seekoff (_strbuf, off,
145: (_IO_seekflags)
146: ((int)dir | _IO_seek_not_out | _IO_seek_pos_ignored));
147: if (pos == streampos(EOF))
148: set(ios::badbit);
149: return *this;
150: }
151:
152: streampos istream::tellg()
153: {
154: #if 0
155: streampos pos = _strbuf->sseekoff(0, ios::cur, ios::in);
156: #else
157: streampos pos
158: = _IO_seekoff (_strbuf, 0,
159: (_IO_seekflags)(_IO_seek_cur | _IO_seek_not_out));
160: #endif
161: if (pos == streampos(EOF))
162: set(ios::badbit);
163: return pos;
164: }
165:
166: istream& istream::operator>>(char& c)
167: {
168: if (ipfx0()) {
169: int ch = _strbuf->sbumpc();
170: if (ch == EOF)
171: set(ios::eofbit|ios::failbit);
172: else
173: c = (char)ch;
174: }
175: return *this;
176: }
177:
178: istream& istream::operator>>(char* ptr)
179: {
180: register char *p = ptr;
181: int w = width(0);
182: if (ipfx0()) {
183: register streambuf* sb = _strbuf;
184: for (;;)
185: {
186: int ch = sb->sbumpc();
187: if (ch == EOF)
188: {
189: set(p == ptr ? (ios::eofbit|ios::failbit) : (ios::eofbit));
190: break;
191: }
192: else if (isspace(ch))
193: {
194: sb->sputbackc(ch);
195: break;
196: }
197: else if (w == 1)
198: {
199: set(ios::failbit);
200: sb->sputbackc(ch);
201: break;
202: }
203: else *p++ = ch;
204: w--;
205: }
206: }
207: *p = '\0';
208: return *this;
209: }
210:
211: #if defined(__GNUC__) && !defined(__STRICT_ANSI__)
212: #define LONGEST long long
213: #else
214: #define LONGEST long
215: #endif
216:
217: static int read_int(istream& stream, unsigned LONGEST& val, int& neg)
218: {
219: if (!stream.ipfx0())
220: return 0;
221: register streambuf* sb = stream.rdbuf();
222: int base = 10;
223: int ndigits = 0;
224: register int ch = skip_ws(sb);
225: if (ch == EOF)
226: goto eof_fail;
227: neg = 0;
228: if (ch == '+') {
229: ch = skip_ws(sb);
230: }
231: else if (ch == '-') {
232: neg = 1;
233: ch = skip_ws(sb);
234: }
235: if (ch == EOF) goto eof_fail;
236: if (!(stream.flags() & ios::basefield)) {
237: if (ch == '0') {
238: ch = sb->sbumpc();
239: if (ch == EOF) {
240: val = 0;
241: return 1;
242: }
243: if (ch == 'x' || ch == 'X') {
244: base = 16;
245: ch = sb->sbumpc();
246: if (ch == EOF) goto eof_fail;
247: }
248: else {
249: sb->sputbackc(ch);
250: base = 8;
251: ch = '0';
252: }
253: }
254: }
255: else if ((stream.flags() & ios::basefield) == ios::hex)
256: base = 16;
257: else if ((stream.flags() & ios::basefield) == ios::oct)
258: base = 8;
259: val = 0;
260: for (;;) {
261: if (ch == EOF)
262: break;
263: int digit;
264: if (ch >= '0' && ch <= '9')
265: digit = ch - '0';
266: else if (ch >= 'A' && ch <= 'F')
267: digit = ch - 'A' + 10;
268: else if (ch >= 'a' && ch <= 'f')
269: digit = ch - 'a' + 10;
270: else
271: digit = 999;
272: if (digit >= base) {
273: sb->sputbackc(ch);
274: if (ndigits == 0)
275: goto fail;
276: else
277: return 1;
278: }
279: ndigits++;
280: val = base * val + digit;
281: ch = sb->sbumpc();
282: }
283: return 1;
284: fail:
285: stream.set(ios::failbit);
286: return 0;
287: eof_fail:
288: stream.set(ios::failbit|ios::eofbit);
289: return 0;
290: }
291:
292: #define READ_INT(TYPE) \
293: istream& istream::operator>>(TYPE& i)\
294: {\
295: unsigned LONGEST val; int neg;\
296: if (read_int(*this, val, neg)) {\
297: if (neg) val = -val;\
298: i = (TYPE)val;\
299: }\
300: return *this;\
301: }
302:
303: READ_INT(short)
304: READ_INT(unsigned short)
305: READ_INT(int)
306: READ_INT(unsigned int)
307: READ_INT(long)
308: READ_INT(unsigned long)
309: #if defined(__GNUC__) && !defined(__STRICT_ANSI__)
310: READ_INT(long long)
311: READ_INT(unsigned long long)
312: #endif
313:
314: istream& istream::operator>>(double& x)
315: {
316: if (ipfx0())
317: scan("%lg", &x);
318: return *this;
319: }
320:
321: istream& istream::operator>>(float& x)
322: {
323: if (ipfx0())
324: scan("%g", &x);
325: return *this;
326: }
327:
328: istream& istream::operator>>(register streambuf* sbuf)
329: {
330: if (ipfx0()) {
331: register streambuf* inbuf = rdbuf();
332: // FIXME: Should optimize!
333: for (;;) {
334: register int ch = inbuf->sbumpc();
335: if (ch == EOF) {
336: set(ios::eofbit);
337: break;
338: }
339: if (sbuf->sputc(ch) == EOF) {
340: set(ios::failbit);
341: break;
342: }
343: }
344: }
345: return *this;
346: }
347:
348: ostream& ostream::operator<<(char c)
349: {
350: if (opfx()) {
351: #if 1
352: // This is what the cfront implementation does.
353: if (_strbuf->sputc(c) == EOF)
354: goto failed;
355: #else
356: // This is what cfront documentation and current ANSI drafts say.
357: int w = width(0);
358: char fill_char = fill();
359: register int padding = w > 0 ? w - 1 : 0;
360: register streambuf *sb = _strbuf;
361: if (!(flags() & ios::left) && padding) // Default adjustment.
362: if (_IO_padn(sb, fill_char, padding) < padding)
363: goto failed;
364: if (sb->sputc(c) == EOF)
365: goto failed;
366: if (flags() & ios::left && padding) // Left adjustment.
367: if (_IO_padn(sb, fill_char, padding) < padding)
368: goto failed;
369: #endif
370: osfx();
371: }
372: return *this;
373: failed:
374: set(ios::badbit);
375: osfx();
376: return *this;
377: }
378:
379: /* Write VAL on STREAM.
380: If SIGN<0, val is the absolute value of a negative number.
381: If SIGN>0, val is a signed non-negative number.
382: If SIGN==0, val is unsigned. */
383:
384: static void write_int(ostream& stream, unsigned LONGEST val, int sign)
385: {
386: #define WRITE_BUF_SIZE (10 + sizeof(unsigned LONGEST) * 3)
387: char buf[WRITE_BUF_SIZE];
388: register char *buf_ptr = buf+WRITE_BUF_SIZE; // End of buf.
389: char *show_base = "";
390: int show_base_len = 0;
391: int show_pos = 0; // If 1, print a '+'.
392:
393: // Now do the actual conversion, placing the result at the *end* of buf.
394: // Note that we use separate code for decimal, octal, and hex,
395: // so we can divide by optimizable constants.
396: if ((stream.flags() & ios::basefield) == ios::oct) { // Octal
397: do {
398: *--buf_ptr = (val & 7) + '0';
399: val = val >> 3;
400: } while (val != 0);
401: if ((stream.flags() & ios::showbase) && (val != 0))
402: *--buf_ptr = '0';
403: }
404: else if ((stream.flags() & ios::basefield) == ios::hex) { // Hex
405: char *xdigs = (stream.flags() & ios::uppercase) ? "0123456789ABCDEF0X"
406: : "0123456789abcdef0x";
407: do {
408: *--buf_ptr = xdigs[val & 15];
409: val = val >> 4;
410: } while (val != 0);
411: if ((stream.flags() & ios::showbase) && (val != 0)) {
412: show_base = xdigs + 16; // Either "0X" or "0x".
413: show_base_len = 2;
414: }
415: }
416: else { // Decimal
417: #if defined(__GNUC__) && !defined(__STRICT_ANSI__)
418: // Optimization: Only use long long when we need to.
419: while (val > UINT_MAX) {
420: *--buf_ptr = (val % 10) + '0';
421: val /= 10;
422: }
423: // Use more efficient (int) arithmetic for the rest.
424: register unsigned int ival = (unsigned int)val;
425: #else
426: register unsigned LONGEST ival = val;
427: #endif
428: do {
429: *--buf_ptr = (ival % 10) + '0';
430: ival /= 10;
431: } while (ival != 0);
432: if (sign > 0 && (stream.flags() & ios::showpos))
433: show_pos=1;
434: }
435:
436: int buf_len = buf+WRITE_BUF_SIZE - buf_ptr;
437: int w = stream.width(0);
438:
439: // Calculate padding.
440: int len = buf_len+show_pos;
441: if (sign < 0) len++;
442: len += show_base_len;
443: int padding = len > w ? 0 : w - len;
444:
445: // Do actual output.
446: register streambuf* sbuf = stream.rdbuf();
447: ios::fmtflags pad_kind =
448: stream.flags() & (ios::left|ios::right|ios::internal);
449: char fill_char = stream.fill();
450: if (padding > 0
451: && pad_kind != (ios::fmtflags)ios::left
452: && pad_kind != (ios::fmtflags)ios::internal) // Default (right) adjust.
453: if (_IO_padn(sbuf, fill_char, padding) < padding)
454: goto failed;
455: if (sign < 0 || show_pos)
456: {
457: char ch = sign < 0 ? '-' : '+';
458: if (sbuf->sputc(ch) < 0)
459: goto failed;
460: }
461: if (show_base_len)
462: if (_IO_sputn(sbuf, show_base, show_base_len) <= 0)
463: goto failed;
464: if (pad_kind == (ios::fmtflags)ios::internal && padding > 0)
465: if (_IO_padn(sbuf, fill_char, padding) < padding)
466: goto failed;
467: if (_IO_sputn (sbuf, buf_ptr, buf_len) != buf_len)
468: goto failed;
469: if (pad_kind == (ios::fmtflags)ios::left && padding > 0) // Left adjustment
470: if (_IO_padn(sbuf, fill_char, padding) < padding)
471: goto failed;
472: stream.osfx();
473: return;
474: failed:
475: stream.set(ios::badbit);
476: stream.osfx();
477: }
478:
479: ostream& ostream::operator<<(int n)
480: {
481: if (opfx()) {
482: int sign = 1;
483: if (n < 0 && (flags() & (ios::oct|ios::hex)) == 0)
484: n = -n, sign = -1;
485: write_int(*this, n, sign);
486: }
487: return *this;
488: }
489:
490: ostream& ostream::operator<<(unsigned int n)
491: {
492: if (opfx())
493: write_int(*this, n, 0);
494: return *this;
495: }
496:
497:
498: ostream& ostream::operator<<(long n)
499: {
500: if (opfx()) {
501: int sign = 1;
502: unsigned int abs_n = (unsigned)n;
503: if (n < 0 && (flags() & (ios::oct|ios::hex)) == 0)
504: abs_n = -((unsigned)n), sign = -1;
505: write_int(*this, abs_n, sign);
506: }
507: return *this;
508: }
509:
510: ostream& ostream::operator<<(unsigned long n)
511: {
512: if (opfx())
513: write_int(*this, n, 0);
514: return *this;
515: }
516:
517: #if defined(__GNUC__) && !defined(__STRICT_ANSI__)
518: ostream& ostream::operator<<(long long n)
519: {
520: if (opfx()) {
521: int sign = 1;
522: unsigned long long abs_n = (unsigned long long)n;
523: if (n < 0 && (flags() & (ios::oct|ios::hex)) == 0)
524: abs_n = -((unsigned long long)n), sign = -1;
525: write_int(*this, abs_n, sign);
526: }
527: return *this;
528: }
529:
530:
531: ostream& ostream::operator<<(unsigned long long n)
532: {
533: if (opfx())
534: write_int(*this, n, 0);
535: return *this;
536: }
537: #endif /*__GNUC__*/
538:
539: ostream& ostream::operator<<(double n)
540: {
541: if (opfx()) {
542: // Uses __cvt_double (renamed from static cvt), in Chris Torek's
543: // stdio implementation. The setup code uses the same logic
544: // as in __vsbprintf.C (also based on Torek's code).
545: int format_char;
546: #if 0
547: if (flags() ios::showpos) sign = '+';
548: #endif
549: if ((flags() & ios::floatfield) == ios::fixed)
550: format_char = 'f';
551: else if ((flags() & ios::floatfield) == ios::scientific)
552: format_char = flags() & ios::uppercase ? 'E' : 'e';
553: else
554: format_char = flags() & ios::uppercase ? 'G' : 'g';
555:
556: int fpprec = 0; // 'Extra' (suppressed) floating precision.
557: int prec = precision();
558: if (prec > MAXFRACT) {
559: if (flags() & (ios::fixed|ios::scientific) & ios::showpos)
560: fpprec = prec - MAXFRACT;
561: prec = MAXFRACT;
562: }
563: else if (prec <= 0 && !(flags() & ios::fixed))
564: prec = 6; /* default */
565:
566: // Do actual conversion.
567: #ifdef USE_DTOA
568: if (_IO_outfloat(n, rdbuf(), format_char, width(0),
569: prec, flags(), 0, fill()) < 0)
570: set(ios::badbit|ios::failbit); // ??
571: #else
572: int negative;
573: char buf[BUF];
574: int sign = '\0';
575: char *cp = buf;
576: *cp = 0;
577: int size = __cvt_double(n, prec,
578: flags() & ios::showpoint ? 0x80 : 0,
579: &negative,
580: format_char, cp, buf + sizeof(buf));
581: if (negative) sign = '-';
582: if (*cp == 0)
583: cp++;
584:
585: // Calculate padding.
586: int fieldsize = size + fpprec;
587: if (sign) fieldsize++;
588: int padding = 0;
589: int w = width(0);
590: if (fieldsize < w)
591: padding = w - fieldsize;
592:
593: // Do actual output.
594: register streambuf* sbuf = rdbuf();
595: register i;
596: char fill_char = fill();
597: ios::fmtflags pad_kind =
598: flags() & (ios::left|ios::right|ios::internal);
599: if (pad_kind != (ios::fmtflags)ios::left // Default (right) adjust.
600: && pad_kind != (ios::fmtflags)ios::internal)
601: for (i = padding; --i >= 0; ) sbuf->sputc(fill_char);
602: if (sign)
603: sbuf->sputc(sign);
604: if (pad_kind == (ios::fmtflags)ios::internal)
605: for (i = padding; --i >= 0; ) sbuf->sputc(fill_char);
606:
607: // Emit the actual concented field, followed by extra zeros.
608: _IO_sputn (sbuf, cp, size);
609: for (i = fpprec; --i >= 0; ) sbuf->sputc('0');
610:
611: if (pad_kind == (ios::fmtflags)ios::left) // Left adjustment
612: for (i = padding; --i >= 0; ) sbuf->sputc(fill_char);
613: #endif
614: osfx();
615: }
616: return *this;
617: }
618:
619: ostream& ostream::operator<<(const char *s)
620: {
621: if (opfx())
622: {
623: if (s == NULL)
624: s = "(null)";
625: int len = strlen(s);
626: int w = width(0);
627: // FIXME: Should we: if (w && len>w) len = w;
628: char fill_char = fill();
629: register streambuf *sbuf = rdbuf();
630: register int padding = w > len ? w - len : 0;
631: if (!(flags() & ios::left) && padding > 0) // Default adjustment.
632: if (_IO_padn(sbuf, fill_char, padding) != padding)
633: goto failed;
634: if (_IO_sputn (sbuf, s, len) != len)
635: goto failed;
636: if (flags() & ios::left && padding > 0) // Left adjustment.
637: if (_IO_padn(sbuf, fill_char, padding) != padding)
638: goto failed;
639: osfx();
640: }
641: return *this;
642: failed:
643: set(ios::badbit);
644: osfx();
645: return *this;
646: }
647:
648: #if 0
649: ostream& ostream::operator<<(const void *p)
650: { Is in osform.cc, to avoid pulling in all of _IO_vfprintf by this file. */ }
651: #endif
652:
653: ostream& ostream::operator<<(register streambuf* sbuf)
654: {
655: if (opfx())
656: {
657: char buffer[_IO_BUFSIZ];
658: register streambuf* outbuf = _strbuf;
659: for (;;)
660: {
661: _IO_size_t count = _IO_sgetn(sbuf, buffer, _IO_BUFSIZ);
662: if (count <= 0)
663: break;
664: if (_IO_sputn(outbuf, buffer, count) != count)
665: {
666: set(ios::badbit);
667: break;
668: }
669: }
670: osfx();
671: }
672: return *this;
673: }
674:
675: ostream::ostream(streambuf* sb, ostream* tied) : ios(sb, tied)
676: {
677: _flags |= ios::dont_close;
678: }
679:
680: ostream& ostream::seekp(streampos pos)
681: {
682: pos = _strbuf->sseekpos(pos, ios::out);
683: if (pos == streampos(EOF))
684: set(ios::badbit);
685: return *this;
686: }
687:
688: ostream& ostream::seekp(streamoff off, _seek_dir dir)
689: {
690: streampos pos
691: = _IO_seekoff (_strbuf, off,
692: (_IO_seekflags)
693: ((int)dir | _IO_seek_not_in | _IO_seek_pos_ignored));
694: if (pos == streampos(EOF))
695: set(ios::badbit);
696: return *this;
697: }
698:
699: streampos ostream::tellp()
700: {
701: #if 1
702: streampos pos
703: = _IO_seekoff (_strbuf, 0,
704: (_IO_seekflags)(_IO_seek_cur | _IO_seek_not_in));
705: #else
706: streampos pos = _strbuf->sseekoff(0, ios::cur, ios::out);
707: #endif
708: if (pos == streampos(EOF))
709: set(ios::badbit);
710: return pos;
711: }
712:
713: ostream& ostream::flush()
714: {
715: if (_strbuf->_jumps->__sync(_strbuf))
716: set(ios::badbit);
717: return *this;
718: }
719:
720: ostream& flush(ostream& outs)
721: {
722: return outs.flush();
723: }
724:
725: istream& ws(istream& ins)
726: {
727: if (ins.ipfx1()) {
728: int ch = skip_ws(ins._strbuf);
729: if (ch == EOF)
730: ins.set(ios::eofbit);
731: else
732: ins._strbuf->sputbackc(ch);
733: }
734: return ins;
735: }
736:
737: // Skip white-space. Return 0 on failure (EOF), or 1 on success.
738: // Differs from ws() manipulator in that failbit is set on EOF.
739: // Called by ipfx() and ipfx0() if needed.
740:
741: int istream::_skip_ws()
742: {
743: int ch = skip_ws(_strbuf);
744: if (ch == EOF) {
745: set(ios::eofbit|ios::failbit);
746: return 0;
747: }
748: else {
749: _strbuf->sputbackc(ch);
750: return 1;
751: }
752: }
753:
754: ostream& ends(ostream& outs)
755: {
756: outs.put('\0');
757: return outs;
758: }
759:
760: ostream& endl(ostream& outs)
761: {
762: return flush(outs.put('\n'));
763: }
764:
765: ostream& ostream::write(const char *s, int n)
766: {
767: if (opfx()) {
768: if (_IO_sputn(_strbuf, s, n) != n)
769: set(ios::failbit);
770: }
771: return *this;
772: }
773:
774: void ostream::do_osfx()
775: {
776: if (flags() & ios::unitbuf)
777: flush();
778: if (flags() & ios::stdio) {
779: fflush(stdout);
780: fflush(stderr);
781: }
782: }
783:
784: iostream::iostream(streambuf* sb, ostream* tied) : ios(sb, tied)
785: {
786: _flags |= ios::dont_close;
787: }
788:
789: // NOTE: extension for compatibility with old libg++.
790: // Not really compatible with fistream::close().
791: #ifdef _STREAM_COMPAT
792: void ios::close()
793: {
794: if (!(_flags & (unsigned int)ios::dont_close))
795: delete rdbuf();
796: else if (_strbuf->_flags & _IO_IS_FILEBUF)
797: ((struct filebuf*)rdbuf())->close();
798: else if (_strbuf != NULL)
799: rdbuf()->sync();
800: _flags |= ios::dont_close;
801: _strbuf = NULL;
802: _state = badbit;
803: }
804:
805: int istream::skip(int i)
806: {
807: int old = (_flags & ios::skipws) != 0;
808: if (i)
809: _flags |= ios::skipws;
810: else
811: _flags &= ~ios::skipws;
812: return old;
813: }
814: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.