![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to output.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / bin / adb / common_source|
Return to output.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / bin / adb / common_source |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)output.c 5.1 (Berkeley) 1/16/89";
3: #endif
4:
5: /*
6: * adb - output
7: */
8:
9: #include "defs.h"
10: #include <ctype.h>
11: #include <stdio.h>
12: #include <varargs.h>
13:
14: extern char TOODEEP[];
15:
16: int infile;
17: int outfile = 1;
18:
19: char printbuf[LINELEN];
20: char *printptr = printbuf;
21:
22:
23: /*
24: * Print the string s.
25: */
26: prints(s)
27: register char *s;
28: {
29: register int c;
30:
31: while ((c = *s++) != '\0')
32: printc(c);
33: }
34:
35: /*
36: * Print the character c.
37: */
38: printc(c)
39: int c;
40: {
41:
42: if (mkfault)
43: return;
44: switch (c) {
45:
46: case 0:
47: return;
48:
49: case '\n':
50: sendout();
51: return;
52:
53: default:
54: if (isprint(c))
55: *printptr++ = c;
56: break;
57: }
58: if (printptr >= &printbuf[LINELEN - 1]) /* 1 == space for \n */
59: sendout();
60: }
61:
62: /*
63: * Send (write) out the contents of the print buffer, compressing
64: * spaces into tabs.
65: */
66: static
67: sendout()
68: {
69: register char *p, *q;
70: register int c, off = 0, spaces = 0, s;
71: #define tabsize(x) (8 - ((x) & 7))
72:
73: for (q = p = printbuf; p < printptr;) {
74: c = *p++;
75: switch (c) {
76:
77: case ' ':
78: spaces++;
79: break;
80:
81: case '\t':
82: spaces += tabsize(off + spaces);
83: break;
84:
85: default:
86: s = tabsize(off);
87: off += spaces + 1;
88: while (spaces >= s) {
89: *q++ = '\t';
90: spaces -= s;
91: s = 8;
92: }
93: while (--spaces >= 0)
94: *q++ = ' ';
95: spaces = 0;
96: *q++ = c;
97: }
98: }
99: *q++ = '\n';
100: (void) write(outfile, printbuf, q - printbuf);
101: printptr = printbuf;
102: #undef tabsize
103: }
104:
105: charpos()
106: {
107:
108: return (printptr - printbuf);
109: }
110:
111: endline()
112: {
113:
114: if (printptr - printbuf >= maxcol)
115: printc('\n');
116: }
117:
118: flushbuf()
119: {
120:
121: if (printptr != printbuf)
122: sendout();
123: }
124:
125: /* this should not be necessary! */
126: #ifdef lint
127: #undef va_arg
128: #define va_arg(ap, type) (ap = ap, (type)0)
129: #endif
130:
131: /*
132: * Context passed between adbprintf and decodefmt.
133: */
134: struct prf {
135: char *fmt; /* format pointer */
136: va_list ap; /* argument pointer */
137: char *buf; /* digit buffer, or %s string */
138: int adj; /* 'l'eft (-) or 'r'ight adjustment */
139: int width; /* width from format */
140: int prec; /* precision from format */
141: };
142:
143: /*
144: * adb's very own version of printf() ... of course, all the format
145: * escapes are different. Noteworthy are the %<width>m and %<tabstop>t
146: * formats, which move the given width, or to the given tabstop, and
147: * the %?a format, which evaluates one argument, and if not zero, prints
148: * according to format a. (Note that any modifiers must appear in the
149: * `a' part, not in the %? part.)
150: */
151: /* VARARGS1 */
152: adbprintf(fmt, va_alist)
153: char *fmt;
154: va_dcl
155: {
156: register char *s;
157: register int n, c;
158: struct prf prf;
159: char digits[130]; /* good to at least 128 bit expr_t */
160:
161: /* set up the fields adbprf needs */
162: prf.fmt = fmt;
163: va_start(prf.ap);
164: for (;;) {
165: /* look for % conversions */
166: s = prf.fmt;
167: while ((c = *s++) != '%') {
168: if (c == 0)
169: return;
170: printc(c);
171: }
172: prf.fmt = s;
173: prf.buf = digits;
174: dofmt(&prf); /* format one format */
175: n = strlen(s = prf.buf);
176: if (prf.prec >= 0 && n > prf.prec)
177: n = prf.prec;
178: c = prf.width - n;
179: if (prf.adj == 'r')
180: while (--c >= 0)
181: printc(' ');
182: while (--n >= 0)
183: printc(*s++);
184: while (--c >= 0)
185: printc(' ');
186: }
187: va_end(prf.ap);
188: }
189:
190: /*
191: * Do a single format.
192: */
193: static
194: dofmt(prf)
195: register struct prf *prf;
196: {
197: register char *s = prf->fmt;
198: register va_list ap = prf->ap;
199: register int c, n;
200: expr_t v;
201: int pluspref = 0;
202: static char null[] = "";
203:
204: prf->adj = 'r';
205: prf->width = 0;
206: prf->prec = -1;
207: more:
208: c = *s++;
209: sw:
210: switch (c) {
211:
212: case '-':
213: prf->adj = 'l';
214: goto more;
215:
216: case '+':
217: pluspref = 1;
218: goto more;
219:
220: case '*':
221: prf->width = va_arg(ap, int);
222: goto more;
223:
224: case '0': case '1': case '2': case '3': case '4':
225: case '5': case '6': case '7': case '8': case '9':
226: for (n = c - '0'; isdigit(c = *s++);)
227: n = 10 * n + c - '0';
228: prf->width = n;
229: goto sw;
230:
231: case '.':
232: c = *s++;
233: if (c == '*') {
234: prf->prec = va_arg(ap, int);
235: goto more;
236: }
237: for (n = 0; isdigit(c); c = *s++)
238: n = 10 * n + c - '0';
239: prf->prec = n;
240: goto sw;
241:
242: case 'v': case 'V':
243: /* print in signed version of current radix */
244: if ((n = radix) > 0)
245: n = -n;
246: goto rprint;
247:
248: case 'q': case 'Q': n = -8; goto rprint; /* octal */
249: case 'd': case 'D': n = -10; goto rprint; /* decimal */
250: case 'z': case 'Z': n = -16; goto rprint; /* hex */
251: case 'o': case 'O': n = 8; goto rprint; /* and */
252: case 'u': case 'U': n = 10; goto rprint; /* unsigned */
253: case 'x': case 'X': n = 16; goto rprint; /* versions */
254:
255: case 'r': case 'R':
256: n = radix;
257: rprint:
258: if (isupper(c))
259: v = n < 0 ? SF_ARG : UF_ARG;
260: else
261: v = n < 0 ? SH_ARG : UH_ARG;
262: printradix(prf->buf, v, n, pluspref);
263: break;
264:
265: case 'Y':
266: printdate(prf->buf, va_arg(ap, time_t));
267: break;
268:
269: case 'c':
270: *prf->buf = va_arg(ap, int);
271: prf->buf[1] = 0;
272: break;
273:
274: case 's':
275: prf->buf = va_arg(ap, char *);
276: break;
277:
278: case 'f':
279: /* here comes stdio ... sigh */
280: (void) sprintf(prf->buf, "%+*.*e", prf->width,
281: prf->prec >= 0 ? prf->prec : 16, va_arg(ap, double));
282: prf->prec = -1;
283: break;
284:
285: case 'm':
286: prf->buf = null;
287: break;
288:
289: case 't':
290: if (prf->width)
291: prf->width -= charpos() % prf->width;
292: prf->buf = null;
293: break;
294:
295: case '?':
296: c = va_arg(ap, int);
297: prf->fmt = s;
298: prf->ap = ap;
299: dofmt(prf);
300: if (c == 0)
301: prf->buf = null;
302: return;
303:
304: default:
305: panic("dofmt");
306: /* NOTREACHED */
307: }
308: prf->fmt = s;
309: prf->ap = ap;
310: }
311:
312: /*
313: * Print the date into the buffer at `p'.
314: */
315: static
316: printdate(p, tm)
317: register char *p;
318: time_t tm;
319: {
320: char *asc = ctime(&tm);
321: char *strncpy();
322:
323: (void) strncpy(p, asc + 20, 4); /* "1988" */
324: (void) strncpy(p + 4, asc + 3, 16); /* " Aug 18 03:04:49" */
325: p[20] = 0;
326: }
327:
328: /*
329: * Print the value `val' in base `base' into the buffer at `p'.
330: * If base is negative, assume the number is signed.
331: */
332: static
333: printradix(p, val, base, pluspref)
334: register char *p;
335: register expr_t val;
336: register int base;
337: int pluspref;
338: {
339: register char *d;
340: register expr_t high;
341: char digs[128]; /* good to 128 bits minimum */
342:
343: if (base < 0) {
344: base = -base;
345: if ((sexpr_t)val < 0) {
346: val = -val;
347: *p++ = '-';
348: } else if (pluspref)
349: *p++ = '+';
350: } else if (pluspref)
351: *p++ = '+';
352:
353: d = digs;
354: switch (base) {
355:
356: case 8:
357: while (val != 0) {
358: *d++ = val & 7;
359: val >>= 3;
360: }
361: *d++ = 0;
362: break;
363:
364: case 16:
365: do {
366: *d++ = val & 15;
367: } while ((val >>= 4) != 0);
368: break;
369:
370: default:
371: do {
372: high = val / base;
373: *d++ = val - (high * base);
374: } while ((val = high) != 0);
375: break;
376: }
377: while (d > digs)
378: *p++ = "0123456789abcdef"[*--d];
379: *p = 0;
380: }
381:
382: /*
383: * BEGIN XXX
384: * THIS BELONGS ELSEWHERE
385: */
386: #define MAXIFD 5
387: struct {
388: int fd;
389: expr_t v9;
390: } istack[MAXIFD];
391: int ifiledepth;
392:
393: iclose(stack, err)
394: int stack, err;
395: {
396:
397: if (err) {
398: if (infile) {
399: (void) close(infile);
400: infile = 0;
401: }
402: while (--ifiledepth >= 0)
403: if (istack[ifiledepth].fd)
404: (void) close(istack[ifiledepth].fd);
405: ifiledepth = 0;
406: } else if (stack == 0) {
407: if (infile) {
408: (void) close(infile);
409: infile = 0;
410: }
411: } else if (stack > 0) {
412: if (ifiledepth >= MAXIFD)
413: error(TOODEEP);
414: istack[ifiledepth].fd = infile;
415: istack[ifiledepth].v9 = var[9];
416: ifiledepth++;
417: infile = 0;
418: } else {
419: if (infile) {
420: (void) close(infile);
421: infile = 0;
422: }
423: if (ifiledepth > 0) {
424: infile = istack[--ifiledepth].fd;
425: var[9] = istack[ifiledepth].v9;
426: }
427: }
428: }
429:
430: oclose()
431: {
432:
433: if (outfile != 1) {
434: flushbuf();
435: (void) close(outfile);
436: outfile = 1;
437: }
438: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.