![[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] / researchv8dc / cmd / adb|
Return to output.c CVS log | Up to [Research Unix] / researchv8dc / cmd / adb |
1.1 root 1: #
2: /*
3: *
4: * UNIX debugger
5: *
6: */
7:
8: #include "defs.h"
9: #include <stdio.h>
10:
11:
12: int infile = STDIN;
13: int outfile = STDOUT;
14: int maxpos = MAXPOS;
15: int radix = DEFRADIX;
16:
17: char printbuf[MAXLIN];
18: char *printptr = printbuf;
19: char *digitptr;
20: MSG TOODEEP;
21:
22: printc(c)
23: char c;
24: {
25: char d;
26: register char *q;
27: register int p;
28: int posn, tabs;
29:
30: if (mkfault)
31: return;
32: else if ((*printptr=c)==EOR) {
33: tabs=0;
34: posn=0;
35: q=printbuf;
36: for (p=0; p<printptr-printbuf; p++) {
37: d=printbuf[p];
38: if ((p&7)==0 && posn) {
39: tabs++;
40: posn=0;
41: }
42: if (d==SP)
43: posn++;
44: else {
45: while (tabs>0) {
46: *q++=TB;
47: tabs--;
48: }
49: while (posn>0) {
50: *q++=SP;
51: posn--;
52: }
53: *q++=d;
54: }
55: }
56: *q++=EOR;
57: write(outfile,printbuf,q-printbuf);
58: printptr=printbuf;
59: } else if (c==TB) {
60: *printptr++=SP;
61: while ((printptr-printbuf)&7)
62: *printptr++=SP;
63: } else if (c)
64: printptr++;
65: if (printptr >= &printbuf[MAXLIN-9]) {
66: write(outfile, printbuf, printptr - printbuf);
67: printptr = printbuf;
68: }
69: }
70:
71: charpos()
72: {
73: return(printptr-printbuf);
74: }
75:
76: flushbuf()
77: {
78: if (printptr!=printbuf)
79: printc(EOR);
80: }
81:
82: /*
83: * our very own printf. yes.
84: * `int' things (like %d) expect ints
85: * `long' things (like %D) expect WORDs
86: * there is no %f, for reasons to horrible to explain here
87: */
88:
89: printf(fmat,a1)
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(SP);
234: while (n--)
235: printc(*s++);
236: while (width-- > 0)
237: printc(SP);
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 % 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(TOODEEP);
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.