![[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] / researchv10no / cmd / adb / comm|
Return to output.c CVS log | Up to [Research Unix] / researchv10no / 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 'c':
190: printc((char)*ap++);
191: break;
192:
193: case 's':
194: s = *sp++;
195: ap = (int *)sp;
196: break;
197:
198: /* m is for `move' */
199: case 'm':
200: break;
201:
202: case 'M':
203: width = *ap++;
204: break;
205:
206: case 'T':
207: width = *ap++;
208: /* fall in */
209: case 't':
210: if (width)
211: width -= charpos()%width;
212: break;
213:
214: default:
215: printc(c);
216: break;
217: }
218: if (s == NULL) {
219: *digitptr = 0;
220: s = digits;
221: }
222: n = strlen(s);
223: if (prec >= 0 && prec < n)
224: n = prec;
225: width -= n;
226: if (adj=='r')
227: while (width-- > 0)
228: printc(SPC);
229: while (n--)
230: printc(*s++);
231: while (width-- > 0)
232: printc(SPC);
233: digitptr=digits;
234: }
235: }
236:
237: prints(s)
238: char *s;
239: {
240: printf("%s",s);
241: }
242:
243: newline()
244: {
245: printc(EOR);
246: }
247:
248: convert(cp)
249: register char **cp;
250: {
251: register char c;
252: register int n;
253:
254: n=0;
255: while (isdigit(c = *(*cp)++))
256: n=n*10+c-'0';
257: (*cp)--;
258: return(n);
259: }
260:
261: printmaybe(n, base)
262: WORD n;
263: {
264: if (REALLYNEG(n))
265: printsigned(n, base);
266: else
267: printus(n, base);
268: }
269:
270: printsigned(n, base)
271: WORD n;
272: int base;
273: {
274:
275: if (n < 0) {
276: n = -n;
277: /* if (n < 0) what? */
278: *digitptr++ = '-';
279: }
280: printnum((unsigned long)n, base);
281: }
282:
283: printus(n, base)
284: WORD n;
285: int base;
286: {
287:
288: printnum((unsigned long)n, base);
289: }
290:
291: printnum(n, base)
292: unsigned long n;
293: int base;
294: {
295: unsigned long d;
296: register int r;
297: static char digits[] = "0123456789abcdef";
298:
299: if ((d = n / base) != 0) {
300: printnum(d, base);
301: r = n - (d * base);
302: }
303: else { /* hack for first digit */
304: r = n;
305: if (base == radix) {
306: if (r >= 10)
307: *digitptr++ = '0';
308: }
309: else if (radix == 0)
310: switch (base) {
311: case 16:
312: *digitptr++ = '#';
313: break;
314:
315: case 8:
316: if (r)
317: *digitptr++ = '0';
318: break;
319: }
320: }
321: if (r < sizeof(digits) - 1)
322: *digitptr++ = digits[r];
323: else
324: *digitptr++ = '?';
325: }
326:
327: #define MAXIFD 5
328: struct {
329: int fd;
330: int r9;
331: } istack[MAXIFD];
332: int ifiledepth;
333:
334: iclose(stack, err)
335: {
336: if (err) {
337: if (infile) {
338: close(infile);
339: infile=STDIN;
340: }
341: while (--ifiledepth >= 0)
342: if (istack[ifiledepth].fd)
343: close(istack[ifiledepth].fd);
344: ifiledepth = 0;
345: } else if (stack == 0) {
346: if (infile) {
347: close(infile);
348: infile=STDIN;
349: }
350: } else if (stack > 0) {
351: if (ifiledepth >= MAXIFD)
352: error("$<< nested too deeply");
353: istack[ifiledepth].fd = infile;
354: istack[ifiledepth].r9 = var[9];
355: ifiledepth++;
356: infile = STDIN;
357: } else {
358: if (infile) {
359: close(infile);
360: infile=STDIN;
361: }
362: if (ifiledepth > 0) {
363: infile = istack[--ifiledepth].fd;
364: var[9] = istack[ifiledepth].r9;
365: }
366: }
367: }
368:
369: oclose()
370: {
371: if (outfile!=1) {
372: flushbuf();
373: close(outfile);
374: outfile=STDOUT;
375: }
376: }
377:
378: endline()
379: {
380:
381: if (maxpos <= charpos())
382: newline();
383: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.