![[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 [Research Unix] / researchv9 / cmd / adb / comm|
Return to output.c CVS log | Up to [Research Unix] / researchv9 / cmd / adb / comm |
1.1 root 1: #
2: /*
3: *
4: * UNIX debugger
5: *
6: */
7:
8: #include "defs.h"
9:
10:
11: int infile = STDIN;
12: int outfile = STDOUT;
13: int maxpos = MAXPOS;
14: int radix = 0; /* magic multi-radix */
15:
16: static char printbuf[MAXLIN];
17: static char *printptr = printbuf;
18: static char *digitptr;
19:
20: printc(c)
21: char c;
22: {
23: char d;
24: register char *q;
25: register int p;
26: int posn, tabs;
27:
28: if (mkfault)
29: return;
30: else if ((*printptr=c)==EOR) {
31: tabs=0;
32: posn=0;
33: q=printbuf;
34: for (p=0; p<printptr-printbuf; p++) {
35: d=printbuf[p];
36: if ((p&7)==0 && posn) {
37: tabs++;
38: posn=0;
39: }
40: if (d==SPC)
41: posn++;
42: else {
43: while (tabs>0) {
44: *q++=TB;
45: tabs--;
46: }
47: while (posn>0) {
48: *q++=SPC;
49: posn--;
50: }
51: *q++=d;
52: }
53: }
54: *q++=EOR;
55: write(outfile,printbuf,q-printbuf);
56: printptr=printbuf;
57: } else if (c==TB) {
58: *printptr++=SPC;
59: while ((printptr-printbuf)&7)
60: *printptr++=SPC;
61: } else if (c)
62: printptr++;
63: if (printptr >= &printbuf[MAXLIN-9]) {
64: write(outfile, printbuf, printptr - printbuf);
65: printptr = printbuf;
66: }
67: }
68:
69: charpos()
70: {
71: return(printptr-printbuf);
72: }
73:
74: flushbuf()
75: {
76: if (printptr!=printbuf)
77: printc(EOR);
78: }
79:
80: /*
81: * our very own printf. yes.
82: * `int' things (like %d) expect ints
83: * `long' things (like %D) expect WORDs
84: * there is no %f, for reasons to horrible to explain here
85: *
86: * declare lots of silly arguments because of the cray's calling sequence
87: */
88:
89: printf(fmat, a1, a2, a3, a4, a5, a6, a7, a8, a9)
90: char *fmat;
91: int a1;
92: {
93: register int *ap;
94: register char *s;
95: register int n, width;
96: int prec;
97: char *fptr;
98: int *ip;
99: WORD *lp;
100: char **sp;
101: char c, adj;
102: char digits[64];
103:
104: fptr = fmat;
105: ap = &a1; /* hack */
106: while (c = *fptr++) {
107: if (c!='%') {
108: printc(c);
109: continue;
110: }
111: adj = 'r';
112: if (*fptr=='-') {
113: adj = 'l';
114: fptr++;
115: }
116: width=convert(&fptr);
117: prec = -1;
118: if (*fptr=='.') {
119: fptr++;
120: prec=convert(&fptr);
121: }
122: digitptr=digits;
123: s = NULL;
124: ip = (int *)ap;
125: lp = (long *)ap;
126: sp = (char **)ap;
127: switch (c = *fptr++) {
128:
129: case 'd':
130: printsigned((WORD)*ip++, 10);
131: ap = (int *)ip;
132: break;
133:
134: case 'D':
135: printsigned((WORD)*lp++, 10);
136: ap = (int *)lp;
137: break;
138:
139: case 'u':
140: printus((WORD)*ip++, 10);
141: ap = (int *)ip;
142: break;
143:
144: case 'U':
145: printus((WORD)*lp++, 10);
146: ap = (int *)lp;
147: break;
148:
149: case 'o':
150: printus((WORD)*ip++, 8);
151: ap = (int *)ip;
152: break;
153:
154: case 'O':
155: printus((WORD)*lp++, 8);
156: ap = (int *)lp;
157: break;
158:
159: case 'q':
160: printsigned((WORD)*ip++, 8);
161: ap = (int *)ip;
162: break;
163:
164: case 'Q':
165: printsigned((WORD)*lp++, 8);
166: ap = (int *)lp;
167: break;
168:
169: case 'x':
170: printus((WORD)*ip++, 16);
171: ap = (int *)ip;
172: break;
173:
174: case 'X':
175: printus((WORD)*lp++, 16);
176: ap = (int *)lp;
177: break;
178:
179: case 'r':
180: printmaybe((WORD)*ip++, radix == 0 ? DEFRADIX : radix);
181: ap = (int *)ip;
182: break;
183:
184: case 'R':
185: printmaybe((WORD)*lp++, radix == 0 ? DEFRADIX : radix);
186: ap = (int *)lp;
187: break;
188:
189: case 'Y':
190: printdate((long)*lp++);
191: ap = (int *)lp;
192: break;
193:
194: case 'c':
195: printc((char)*ap++);
196: break;
197:
198: case 's':
199: s = *sp++;
200: ap = (int *)sp;
201: break;
202:
203: /* m is for `move' */
204: case 'm':
205: break;
206:
207: case 'M':
208: width = *ap++;
209: break;
210:
211: case 'T':
212: width = *ap++;
213: /* fall in */
214: case 't':
215: if (width)
216: width -= charpos()%width;
217: break;
218:
219: default:
220: printc(c);
221: break;
222: }
223: if (s == NULL) {
224: *digitptr = 0;
225: s = digits;
226: }
227: n = strlen(s);
228: if (prec >= 0 && prec < n)
229: n = prec;
230: width -= n;
231: if (adj=='r')
232: while (width-- > 0)
233: printc(SPC);
234: while (n--)
235: printc(*s++);
236: while (width-- > 0)
237: printc(SPC);
238: digitptr=digits;
239: }
240: }
241:
242: printdate(tvec)
243: long tvec;
244: {
245: char *ctime();
246:
247: strcpy(digitptr, ctime(&tvec));
248: digitptr += strlen(digitptr) - 1; /* chop the newline */
249: }
250:
251: prints(s)
252: char *s;
253: {
254: printf("%s",s);
255: }
256:
257: newline()
258: {
259: printc(EOR);
260: }
261:
262: convert(cp)
263: register char **cp;
264: {
265: register char c;
266: register int n;
267:
268: n=0;
269: while (isdigit(c = *(*cp)++))
270: n=n*10+c-'0';
271: (*cp)--;
272: return(n);
273: }
274:
275: printmaybe(n, base)
276: WORD n;
277: {
278: if (REALLYNEG(n))
279: printsigned(n, base);
280: else
281: printus(n, base);
282: }
283:
284: printsigned(n, base)
285: WORD n;
286: int base;
287: {
288:
289: if (n < 0) {
290: n = -n;
291: /* if (n < 0) what? */
292: *digitptr++ = '-';
293: }
294: printnum((unsigned long)n, base);
295: }
296:
297: printus(n, base)
298: WORD n;
299: int base;
300: {
301:
302: printnum((unsigned long)n, base);
303: }
304:
305: printnum(n, base)
306: unsigned long n;
307: int base;
308: {
309: unsigned long d;
310: register int r;
311: static char digits[] = "0123456789abcdef";
312:
313: if ((d = n / base) != 0) {
314: printnum(d, base);
315: r = n - (d * base);
316: }
317: else { /* hack for first digit */
318: r = n;
319: if (base == radix) {
320: if (r >= 10)
321: *digitptr++ = '0';
322: }
323: else if (radix == 0)
324: switch (base) {
325: case 16:
326: *digitptr++ = '#';
327: break;
328:
329: case 8:
330: if (r)
331: *digitptr++ = '0';
332: break;
333: }
334: }
335: if (r < sizeof(digits) - 1)
336: *digitptr++ = digits[r];
337: else
338: *digitptr++ = '?';
339: }
340:
341: #define MAXIFD 5
342: struct {
343: int fd;
344: int r9;
345: } istack[MAXIFD];
346: int ifiledepth;
347:
348: iclose(stack, err)
349: {
350: if (err) {
351: if (infile) {
352: close(infile);
353: infile=STDIN;
354: }
355: while (--ifiledepth >= 0)
356: if (istack[ifiledepth].fd)
357: close(istack[ifiledepth].fd);
358: ifiledepth = 0;
359: } else if (stack == 0) {
360: if (infile) {
361: close(infile);
362: infile=STDIN;
363: }
364: } else if (stack > 0) {
365: if (ifiledepth >= MAXIFD)
366: error("$<< nested too deeply");
367: istack[ifiledepth].fd = infile;
368: istack[ifiledepth].r9 = var[9];
369: ifiledepth++;
370: infile = STDIN;
371: } else {
372: if (infile) {
373: close(infile);
374: infile=STDIN;
375: }
376: if (ifiledepth > 0) {
377: infile = istack[--ifiledepth].fd;
378: var[9] = istack[ifiledepth].r9;
379: }
380: }
381: }
382:
383: oclose()
384: {
385: if (outfile!=1) {
386: flushbuf();
387: close(outfile);
388: outfile=STDOUT;
389: }
390: }
391:
392: endline()
393: {
394:
395: if (maxpos <= charpos())
396: newline();
397: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.