1 // This may look like C code, but it is really -*- C++ -*-
2 /*
3 Copyright (C) 1989 Free Software Foundation
4 written by Doug Lea (dl@rocky.oswego.edu)
5
6 This file is part of GNU CC.
7
8 GNU CC is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY. No author or distributor
10 accepts responsibility to anyone for the consequences of using it
11 or for whether it serves any particular purpose or works at all,
12 unless he says so in writing. Refer to the GNU CC General Public
13 License for full details.
14
15 Everyone is granted permission to copy, modify and redistribute
16 GNU CC, but only under the conditions described in the
17 GNU CC General Public License. A copy of this license is
18 supposed to have been given to you along with GNU CC so you
19 can know your rights and responsibilities. It should be in a
20 file named COPYING. Among other things, the copyright notice
21 and this notice must be preserved on all copies.
22 */
23
24 /* *** Version 1.2 -- nearly 100% AT&T 1.2 compatible *** */
25
26 /* ostream.h now separately includable */
27
28 #ifndef _ostream_h
29 #ifdef __GNUG__
30 #pragma once
31 #pragma interface
32 #endif
33 #define _ostream_h 1
34
35 /* uncomment the next line to disable ostream << char */
36 //#define NO_OUTPUT_CHAR
37
38
39 #include <File.h>
40 #include <streambuf.h>
41 #include <filebuf.h>
42 #include <Filebuf.h>
43
44 class istream;
45
46 class ostream
47 {
48 friend class istream;
49 protected:
50 streambuf* bp;
51 state_value state; // _good/_eof/_fail/_bad
52 char ownbuf; // true if we own *bp
53
54 public:
55 ostream(const char* filename, io_mode m, access_mode a);
56 ostream(const char* filename, const char* m);
57 ostream(int filedesc, io_mode m);
58 ostream(FILE* fileptr);
59 ostream(int sz, char* buf);
60 ostream(int filedesc, char* buf, int buflen);
61 ostream(int filedesc);
62 ostream(streambuf* s);
63
64 ~ostream();
65
66 ostream& open(const char* filename, io_mode m, access_mode a);
67 ostream& open(const char* filename, const char* m);
68 ostream& open(int filedesc, io_mode m);
69 ostream& open(FILE* fileptr);
70 ostream& open(const char* filenam, open_mode m);
71
72 ostream& close();
73 ostream& flush();
74
75 // stream status
76
77 int rdstate();
78 int eof();
79 int fail();
80 int bad();
81 int good();
82
83 // other status queries
84
85 int readable();
86 int writable();
87 int is_open();
88
89 operator void*();
90 int operator !();
91
92 const char* name();
93
94 char* bufptr();
95
96 // error handling
97
98 void error();
99 void clear(state_value f = _good); // poorly named
100 void set(state_value f); // set corresponding bit
101 void unset(state_value); // clear corresponding bit
102 ostream& failif(int cond);
103
104 // unformatted IO
105
106 ostream& put(char c);
107 ostream& put(const char* s);
108 ostream& put(const char* s, int slen);
109
110 // formatted IO
111
112 ostream& form(const char* fmt, ...);
113
114 ostream& operator << (short n);
115 ostream& operator << (unsigned short n);
116 ostream& operator << (int n);
117 ostream& operator << (unsigned int n);
118 ostream& operator << (long n);
119 ostream& operator << (unsigned long n);
120 #ifdef __GNUG__
121 ostream& operator << (long long n);
122 ostream& operator << (unsigned long long n);
123 #endif __GNUG__
124 ostream& operator << (float n);
125 ostream& operator << (double n);
126 ostream& operator << (const char* s);
127 ostream& operator << (const void* ptr);
128
129 #ifndef NO_OUTPUT_CHAR
130 ostream& operator << (char c);
131 #endif
132
133 };
134
135 extern ostream cout; // stdout
136 extern ostream cerr; // stderr
137
138 #if defined(__OPTIMIZE__) || defined(USE_LIBGXX_INLINES)
139
140
clear(state_value flag)141 inline void ostream::clear(state_value flag)
142 {
143 state = flag;
144 }
145
set(state_value flag)146 inline void ostream::set(state_value flag)
147 {
148 state = state_value(int(state) | int(flag));
149 }
150
unset(state_value flag)151 inline void ostream::unset(state_value flag)
152 {
153 state = state_value(int(state) & ~int(flag));
154 }
155
rdstate()156 inline int ostream::rdstate()
157 {
158 return int(state);
159 }
160
good()161 inline int ostream::good()
162 {
163 return state == _good;
164 }
165
eof()166 inline int ostream::eof()
167 {
168 return int(state) & int(_eof);
169 }
170
fail()171 inline int ostream::fail()
172 {
173 return int(state) & int(_fail);
174 }
175
bad()176 inline int ostream::bad()
177 {
178 return int(state) & int(_bad);
179 }
180
181 inline ostream::operator void*()
182 {
183 return (state == _good)? this : 0;
184 }
185
186 inline int ostream::operator !()
187 {
188 return (state != _good);
189 }
190
failif(int cond)191 inline ostream& ostream::failif(int cond)
192 {
193 if (cond) set(_fail); return *this;
194 }
195
is_open()196 inline int ostream::is_open()
197 {
198 return bp->is_open();
199 }
200
readable()201 inline int ostream::readable()
202 {
203 return 0;
204 }
205
writable()206 inline int ostream::writable()
207 {
208 return (bp != 0) && (state == _good);
209 }
210
211
bufptr()212 inline char* ostream::bufptr()
213 {
214 return bp->base;
215 }
216
flush()217 inline ostream& ostream::flush()
218 {
219 bp->overflow(); return *this;
220 }
221
close()222 inline ostream& ostream::close()
223 {
224 bp->overflow(); bp->close(); return *this;
225 }
226
put(char ch)227 inline ostream& ostream::put(char ch)
228 {
229 return failif((state != _good) || bp->sputc((int)ch &0xff) == EOF);
230 }
231
232 #ifndef NO_OUTPUT_CHAR
233 inline ostream& ostream::operator << (char ch)
234 {
235 return failif((state != _good) || bp->sputc((int)ch &0xff) == EOF);
236 }
237 #endif
238
put(const char * s)239 inline ostream& ostream::put(const char* s)
240 {
241 return failif((state != _good) || bp->sputs(s) == EOF);
242 }
243
put(const char * s,int len)244 inline ostream& ostream::put(const char* s, int len)
245 {
246 return failif((state != _good) || bp->sputsn(s, len) == EOF);
247 }
248
249 inline ostream& ostream::operator << (const char* s)
250 {
251 return failif((state != _good) || bp->sputs(s) == EOF);
252 }
253
254 #endif
255
256 #endif
257