![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to out.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 out.c CVS log | Up to [Research Unix] / researchv9 / cmd / cfront / libC / stream |
1.1 root 1: /*
2: C++ stream i/o source
3:
4: out.c
5: */
6: strlen(const char*);
7: #include "stream.h"
8: #include <common.h>
9:
10:
11: #define MAXOSTREAMS 20
12:
13: char cout_buf[BUFSIZE];
14: filebuf cout_file(stdout); // UNIX output stream 1
15: ostream cout(&cout_file);
16:
17: char cerr_buf[1];
18: filebuf cerr_file(stderr); // UNIX output stream 2
19: ostream cerr(&cerr_file);
20:
21: const cb_size = 1024;
22: const fld_size = 256;
23:
24: /* a circular formating buffer */
25: static char formbuf[cb_size]; // some slob for form overflow
26: static char* bfree=formbuf;
27: static char* max = &formbuf[cb_size-1];
28:
29: char* chr(register i, register int w) /* note: chr(0) is "" */
30: {
31: register char* buf = bfree;
32:
33: if (w<=0 || fld_size<w) w = 1;
34: w++; /* space for trailing 0 */
35: if (max < buf+w) buf = formbuf;
36: bfree = buf+w;
37: char * res = buf;
38:
39: w -= 2; /* pad */
40: while (w--) *buf++ = ' ';
41: if (i<0 || 127<i) i = ' ';
42: *buf++ = i;
43: *buf = 0;
44: return res;
45: }
46:
47: char* str(const char* s, register int w)
48: {
49: register char* buf = bfree;
50: int ll = strlen(s);
51: if (w<=0 || fld_size<w) w = ll;
52: if (w < ll) ll = w;
53: w++; /* space for traling 0 */
54: if (max < buf+w) buf = formbuf;
55: bfree = buf+w;
56: char* res = buf;
57:
58: w -= (ll+1); /* pad */
59: while (w--) *buf++ = ' ';
60: while (*s) *buf++ = *s++;
61: *buf = 0;
62: return res;
63: }
64:
65: char* form(const char* format ...)
66: {
67: register* ap = (int*)((char*)&format+sizeof(char*)); // not completely general
68: register char* buf = bfree;
69: if (max < buf+fld_size) buf = formbuf;
70:
71: register ll = sprintf(buf,format,ap[0],ap[1],ap[2],ap[3],ap[4],ap[5],ap[6],ap[7],ap[8],ap[9]); // too few words copied
72: if (0<ll && ll<cb_size) // length
73: ;
74: else if (buf<(char*)ll && (char*)ll<buf+cb_size)// pointer to trailing 0
75: ll = (char*)ll - buf;
76: else
77: ll = strlen(buf);
78: if (fld_size < ll) exit(10);
79: bfree = buf+ll+1;
80: return buf;
81: }
82:
83: const char a10 = 'a'-10;
84:
85: char* hex(long ii, register w)
86: {
87: int m = sizeof(long)*2; // maximum hex digits for a long
88: if (w<0 || fld_size<w) w = 0;
89: int sz = (w?w:m)+1;
90: register char* buf = bfree;
91: if (max < buf+sz) buf = formbuf;
92: register char* p = buf+sz;
93: bfree = p+1;
94: *p-- = 0; // trailing 0
95: register unsigned long i = ii;
96:
97: if (w) {
98: do {
99: register h = i&0xf;
100: *p-- = (h < 10) ? h+'0' : h+a10;
101: } while (--w && (i>>=4));
102: while (0<w--) *p-- = ' ';
103: }
104: else {
105: do {
106: register h = i&0xf;
107: *p-- = (h < 10) ? h+'0' : h+a10;
108: } while (i>>=4);
109: }
110: return p+1;
111: }
112:
113: char* oct(long ii, int w)
114: {
115: int m = sizeof(long)*3; // maximum oct digits for a long
116: if (w<0 || fld_size<w) w = 0;
117: int sz = (w?w:m)+1;
118: register char* buf = bfree;
119: if (max < buf+sz) buf = formbuf;
120: register char* p = buf+sz;
121: bfree = p+1;
122: *p-- = 0; // trailing 0
123: register unsigned long i = ii;
124:
125: if (w) {
126: do {
127: register h = i&07;
128: *p-- = h + '0';
129: } while (--w && (i>>=3));
130: while (0<w--) *p-- = ' ';
131: }
132: else {
133: do {
134: register h = i&07;
135: *p-- = h+'0';
136: } while (i>>=3);
137: }
138:
139: return p+1;
140: }
141:
142: char* dec(long i, int w)
143: {
144: int sign = 0;
145: if (i < 0) {
146: sign = 1;
147: i = -i;
148: }
149: int m = sizeof(long)*3; /* maximum dec digits for a long */
150: if (w<0 || fld_size<w) w = 0;
151: int sz = (w?w:m)+1;
152: register char* buf = bfree;
153: if (max < buf+sz) buf = formbuf;
154: register char* p = buf+sz;
155: bfree = p+1;
156: *p-- = 0; /* trailing 0 */
157:
158: if (w) {
159: do {
160: register h = i%10;
161: *p-- = h + '0';
162: } while (--w && (i/=10));
163: if (sign && 0<w) {
164: w--;
165: *p-- = '-';
166: }
167: while (0<w--) *p-- = ' ';
168: }
169: else {
170: do {
171: register h = i%10;
172: *p-- = h + '0';
173: } while (i/=10);
174: if (sign) *p-- = '-';
175: }
176:
177: return p+1;
178: }
179:
180:
181: ostream& ostream.operator<<(const char* s)
182: {
183: register streambuf* nbp = bp;
184:
185: if (state || s==0 || *s==0) return *this;
186:
187: do
188: if (nbp->sputc(*s++) == EOF) {
189: state |= _eof|_fail;
190: break;
191: }
192: while (*s);
193:
194: return *this;
195: }
196:
197: ostream& ostream.operator<<(long i)
198: {
199: register streambuf* nbp = bp;
200: register long j;
201: char buf[32];
202: register char *p = buf;
203:
204: if (state) return *this;
205:
206: if (i < 0) {
207: nbp->sputc('-');
208: j = -i;
209: } else
210: j = i;
211:
212: do {
213: *p++ = '0' + j%10;
214: j = j/10;
215: } while (j > 0);
216:
217: do {
218: if (nbp->sputc(*--p) == EOF) {
219: state |= _fail | _eof;
220: break;
221: }
222: } while (p != buf);
223:
224: return *this;
225: }
226:
227: ostream& ostream.put(char c)
228: {
229: if (state) return *this;
230:
231: if (bp->sputc(c) == EOF) state |= _eof|_fail;
232:
233: return *this;
234: }
235:
236: ostream& ostream.operator<<(double d)
237: {
238: register streambuf* nbp = bp;
239: char buf[32];
240: register char *p = buf;
241:
242: if (state) return *this;
243:
244: sprintf(buf,"%g",d);
245: while (*p != '\0')
246: if (nbp->sputc(*p++) == EOF) {
247: state |= _eof|_fail;
248: break;
249: }
250: return *this;
251: }
252:
253: ostream& ostream.operator<<(const streambuf& b)
254: {
255: register streambuf* nbp = bp;
256: register int c;
257:
258: if (state) return *this;
259:
260: c = b.sgetc();
261: while (c != EOF) {
262: if (nbp->sputc(c) == EOF) {
263: state |= _eof|_fail;
264: break;
265: }
266: c = b.snextc();
267: }
268:
269: return *this;
270: }
271:
272:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.