![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to trace3.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / db|
Return to trace3.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / db |
1.1 root 1: /*
2: * A debugger.
3: * Display.
4: */
5: #include <stdio.h>
6: #include <ctype.h>
7: #include "trace.h"
8:
9: /*
10: * Execute a command string.
11: */
12: execute(cp)
13: char *cp;
14: {
15: register INP *ip;
16:
17: while ((ip=inpp) != NULL) {
18: inpp = ip->i_next;
19: nfree(ip);
20: }
21: modsize = sizeof(int);
22: sincmod = SNULL;
23: dot = getpc();
24: lastc = '\0';
25: addstrp(cp);
26: request();
27: testint();
28: }
29:
30: /*
31: * Parse requests and execute them.
32: */
33: request()
34: {
35: register int c;
36: register char *cp;
37: register unsigned segn;
38: register long l;
39: register long d;
40: VAL val[VALSIZE];
41:
42: while ((c=getn()) != EOF) {
43: if (c == '!') {
44: syscall();
45: continue;
46: }
47: if (c == '?') {
48: if ((c=getn()) != '\n') {
49: printe("Syntax error");
50: goto next;
51: }
52: if (errrstr == NULL)
53: printx("No error\n");
54: else
55: printx("%s\n", errrstr);
56: continue;
57: }
58: ungetn(c);
59: if (explist(val) == 0)
60: goto next;
61: switch (c=getn()) {
62: case ':':
63: sincmod = SNULL;
64: if (command(val) == 0)
65: return;
66: continue;
67: case '\n':
68: if (nvalue(&val[0]) && sincmod!=SNULL) {
69: if (excflag == 0) {
70: sincmod = SNULL;
71: printe("Cannot single step");
72: continue;
73: }
74: sinmode = sincmod;
75: sindecr = rvalue(&val[1], (long)1);
76: return;
77: }
78: case '=':
79: ungetn(c);
80: case '?':
81: sincmod = SNULL;
82: segn = vsegno(&val[0], cseg);
83: if ((c=getn()) == '=') {
84: l = lvalue(&val[0], (long)dot);
85: if ((c=getn()) == '\n') {
86: putaddnum( l);
87: printx("\n");
88: continue;
89: }
90: ungetn(c);
91: if (setdata(segn, l) == 0)
92: break;
93: continue;
94: }
95: if (c != '\n') {
96: cp = &segform[segn][0];
97: while (c != '\n') {
98: *cp++ = c;
99: c = getn();
100: }
101: *cp++ = '\0';
102: }
103: d = dot;
104: l = lad;
105: dot = lvalue(&val[0], (long)lad);
106: dispfmt(segn, segform[segn],
107: (int)rvalue(&val[1], (long)1));
108: if (segn != 2)
109: cseg = segn;
110: else {
111: dot = d;
112: lad = l;
113: }
114: continue;
115: default:
116: sincmod = SNULL;
117: printe("Syntax error");
118: break;
119: }
120: next:
121: while ((c=getn()) != '\n')
122: ;
123: }
124: }
125:
126: /*
127: * Change the value of a location.
128: */
129: setdata(segn, a)
130: long a;
131: {
132: register char *cp;
133: register int n;
134: register int c;
135: char b[1];
136: char l3[3];
137: int i[1];
138: long l[1];
139: VAL val[VALSIZE];
140:
141: if (explist(val) == 0)
142: return (0);
143: if ((c=getn()) != '\n')
144: return (0);
145: for (n=0; n<VALSIZE; n++, a+=modsize) {
146: if (nvalue(&val[n]))
147: continue;
148: l[0] = rvalue(&val[n], (long)0);
149: switch (modsize) {
150: case (sizeof(char)):
151: b[0] = l[0];
152: cp = b;
153: break;
154: case (sizeof(int)):
155: i[0] = l[0];
156: cp = i;
157: break;
158: case (sizeof(l3)):
159: ltol3(l3, l, 1);
160: cp = l3;
161: break;
162: case (sizeof(long)):
163: cp = l;
164: break;
165: default:
166: printe("Bad change type");
167: return (1);
168: }
169: add = a;
170: if (putb(segn, cp, modsize) == 0) {
171: printe("Cannot change value");
172: return (1);
173: }
174: }
175: if (segn == 2)
176: setregs();
177: return (1);
178: }
179:
180: /*
181: * Send a command to the shell.
182: */
183: syscall()
184: {
185: register int c;
186: register char *cp;
187:
188: cp = miscbuf;
189: while ((c=getn()) != '\n')
190: *cp++ = c;
191: *cp++ = '\0';
192: system(miscbuf);
193: testint();
194: printf("!\n");
195: }
196:
197: /*
198: * Print out data according to a format string. `n' is the number
199: * of times this is done.
200: */
201:
202: static int addfmt = 32767;
203:
204: dispfmt(s, fs, n)
205: char *fs;
206: {
207: register char *sp1;
208: register char *sp2;
209: register int c;
210: register int r;
211: register int t1;
212: register int t2;
213: register char *sp3;
214: register char *fp;
215: register long nad;
216: register long pad;
217: register long uad;
218:
219: r = 1;
220: t2 = '\0';
221: add = dot;
222: nad = dot;
223: pad = dot;
224: uad = dot;
225: sp1 = miscbuf;
226: sp3 = &sp1[DISSIZE];
227: while (n--) {
228: fp = fs;
229: for (;;) {
230: c = *fp++;
231: if (isascii(c) && isdigit(c)) {
232: r = 0;
233: do {
234: r = r*10 + c-'0';
235: c = *fp++;
236: } while (isascii(c) && isdigit(c));
237: --fp;
238: continue;
239: }
240: switch (c) {
241: case '^':
242: add = uad;
243: continue;
244: case '+':
245: add += r;
246: r = 1;
247: continue;
248: case '-':
249: add -= r;
250: r = 1;
251: continue;
252: case 'n':
253: *sp1 = '\0';
254: flushb((long)nad);
255: sp1 = miscbuf;
256: nad = add;
257: continue;
258: case 'd':
259: case 'o':
260: case 'u':
261: case 'x':
262: t2 = c;
263: continue;
264: case 'a':
265: addfmt = 32767;
266: continue;
267: case 'A':
268: addfmt = -1;
269: continue;
270: default:
271: t1 = c;
272: if (t1=='\0' && t2=='\0')
273: break;
274: if (t1 == '\0')
275: t1 = 'w';
276: if (t2 == '\0')
277: t2 = DDCHR;
278: uad = add;
279: while (r--) {
280: if (testint())
281: return (1);
282: *sp1++ = ' ';
283: pad = add;
284: sp2 = conform(sp1, s, t1, t2, getb);
285: if (sp2 == NULL) {
286: *--sp1 = '\0';
287: if (sp1 != miscbuf)
288: flushb((long)nad);
289: printe("Addressing error");
290: return (0);
291: }
292: if (sp2 <= sp3)
293: sp1 = sp2;
294: else {
295: *--sp1 = '\0';
296: flushb((long)nad);
297: *sp2 = '\0';
298: *sp1 = ' ';
299: sp2 = sp1;
300: sp1 = miscbuf;
301: while (*sp2)
302: *sp1++ = *sp2++;
303: nad = pad;
304: }
305: if (c == 'i') {
306: *sp1++ = '\0';
307: flushb((long)nad);
308: sp1 = miscbuf;
309: nad = add;
310: }
311: }
312: r = 1;
313: t2 = '\0';
314: if (c != '\0')
315: continue;
316: }
317: break;
318: }
319: lad = add;
320: }
321: if (sp1 != miscbuf) {
322: *sp1 = '\0';
323: flushb((long)nad);
324: }
325: return (1);
326: }
327:
328: /*
329: * Flush the output buffer. The given address `a' is printed before the
330: * contents of the buffer and dot is set to it.
331: */
332: flushb(a)
333: register long a;
334: {
335: char buf[40];
336:
337: dot = a;
338: if( fflag)
339: printx( "%lx", a);
340: else {
341: conaddr( buf, -1, a, addfmt);
342: printx( "%s", buf);
343: }
344: printx("\t%s\n", miscbuf);
345: }
346:
347: /*
348: * Given a format character `f' and a function `func', print out
349: * data according to the given format. The function `get' is
350: * called to read characters.
351: */
352: char *
353: conform(sp, s, t1, t2, get)
354: register char *sp;
355: int (*get)();
356: {
357: register char *lp;
358: unsigned char c[1];
359: unsigned char v[3];
360: unsigned short h[1];
361: char *p[1];
362: int i[1];
363: long l[1];
364: #ifndef NFP
365: float f[1];
366: double d[1];
367: #endif
368:
369: switch (t1) {
370: case 'b':
371: if ((*get)(s, c, sizeof(c)) == 0)
372: return (NULL);
373: modsize = sizeof(c);
374:
375: /*
376: * There should be a better way to do this.
377: */
378: if (t2 != 'd')
379: i[0] = c[0];
380: else {
381: char x[1];
382:
383: x[0] = c[0];
384: i[0] = x[0];
385: }
386: sprintf(sp, getform(t1, t2), i[0]);
387: break;
388: case 'c':
389: if ((*get)(s, c, sizeof(c)) == 0)
390: return (NULL);
391: modsize = sizeof(c);
392: sp = conescs(sp, c[0]);
393: return (sp);
394: case 'C':
395: if ((*get)(s, c, sizeof(c)) == 0)
396: return (NULL);
397: modsize = sizeof(c);
398: *sp++ = (c[0]>=040&&c[0]<0177) ? c[0] : '.';
399: return (sp);
400: #ifndef NFP
401: case 'f':
402: if ((*get)(s, (char *)f, sizeof(f)) == 0)
403: return (NULL);
404: modsize = sizeof(f);
405: sprintf(sp, getform(t1, t2), f[0]);
406: break;
407: case 'F':
408: if ((*get)(s, (char *)d, sizeof(d)) == 0)
409: return (NULL);
410: modsize = sizeof(d);
411: sprintf(sp, getform(t1, t2), d[0]);
412: break;
413: #endif
414: case 'h':
415: if ((*get)(s, h, sizeof(h)) == 0)
416: return (NULL);
417: modsize = sizeof(h);
418:
419: /*
420: * Oh well.
421: */
422: if (t2 != 'd')
423: i[0] = h[0];
424: else {
425: short x[1];
426:
427: x[0] = h[0];
428: i[0] = x[0];
429: }
430: sprintf(sp, getform(t1, t2), i[0]);
431: break;
432: case 'i':
433: sp = coninst(sp, s);
434: modsize = INLEN;
435: return (sp);
436: case 'l':
437: if ((*get)(s, (char *)l, sizeof(l)) == 0)
438: return (NULL);
439: modsize = sizeof(l);
440: sprintf(sp, getform(t1, t2), l[0]);
441: break;
442: case 'p':
443: if ((*get)(s, (char *)p, sizeof(p)) == 0)
444: return (NULL);
445: modsize = sizeof(p);
446: sp = conaddr(sp, -1, (long)p[0], I);
447: return (sp);
448: case 's':
449: case 'S':
450: lp = &sp[DISSIZE];
451: c[0] = '\0';
452: for (;;) {
453: if ((*get)(s, c, sizeof(c)) == 0)
454: return (NULL);
455: if (c[0] == '\0')
456: break;
457: if (t1 == 's')
458: sp = conescs(sp, c[0]);
459: else
460: *sp++ = c[0];
461: if (sp > lp)
462: return (NULL);
463: }
464: modsize = sizeof(i);
465: return (sp);
466: case 'v':
467: if ((*get)(s, (char *)v, sizeof(v)) == 0)
468: return (NULL);
469: modsize = sizeof(v);
470: l3tol(l, v, 1);
471: sprintf(sp, getform(t1, t2), l[0]);
472: break;
473: case 'w':
474: if ((*get)(s, (char *)i, sizeof(i)) == 0)
475: return (NULL);
476: modsize = sizeof(i);
477: sprintf(sp, getform(t1, t2), i[0]);
478: break;
479: case 'Y':
480: sp = gettime(sp, cseg, get);
481: modsize = sizeof(i);
482: return (sp);
483: default:
484: return (NULL);
485: }
486: while (*sp)
487: sp++;
488: return (sp);
489: }
490:
491: /*
492: * If the given character is unprintable, convert it into
493: * an escape sequence.
494: */
495: char *
496: conescs(sp, c)
497: register char *sp;
498: register int c;
499: {
500: *sp++ = '\\';
501: switch (c) {
502: case '\0':
503: *sp++ = '0';
504: break;
505: case '\b':
506: *sp++ = 'b';
507: break;
508: case '\n':
509: *sp++ = 'n';
510: break;
511: case '\f':
512: *sp++ = 'f';
513: break;
514: case '\r':
515: *sp++ = 'r';
516: break;
517: case '\\':
518: *sp++ = '\\';
519: break;
520: default:
521: if (c<040 || c>=0177) {
522: sprintf(sp, "%03o", c);
523: while (*sp)
524: sp++;
525: break;
526: }
527: sp[-1] = c;
528: }
529: return (sp);
530: }
531:
532: /*
533: * Get the current time.
534: */
535: char *
536: gettime(sp, s, get)
537: register char *sp;
538: int (*get)();
539: {
540: long l;
541: register int n;
542: register char *cp;
543:
544: if ((*get)(s, (char *) &l, sizeof(l)) == 0)
545: return (NULL);
546: cp = ctime(&l);
547: n = 24;
548: do {
549: *sp++ = *cp++;
550: } while (--n);
551: return (sp);
552: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.