![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to docomm.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd / sdb|
Return to docomm.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / sdb |
1.1 root 1: #include <signal.h>
2: #include "head.h"
3: #include <a.out.h>
4:
5: struct user u;
6: L_INT cntval;
7: INT signo;
8: INT adrflg;
9: INT pid;
10: ADDR userpc;
11: char *s;
12: enum {NOCOM, PRCOM, DSCOM} lastcom;
13:
14: docommand() {
15: register char *p;
16: register int i;
17: register ADDR addr, bkaddr;
18: struct proct *procp;
19:
20: cntval = 1;
21: adrflg = 0;
22: errflg = 0;
23:
24: if (scallf) {
25: doscall();
26: setcur(1);
27: lastcom = NOCOM;
28: return;
29: }
30:
31: if (reflag) { /* search for regular expression */
32: dore();
33: lastcom = PRCOM;
34: return;
35: }
36:
37: if (cmd == '\0') {
38: if (integ != 0 && var[0] != '\0') {
39: error("Invalid command (1)");
40: return;
41: }
42: if (integ != 0) { /* print line number */
43: ffind(integ);
44: fprint();
45: lastcom = PRCOM;
46: return;
47: }
48: if (var[0] != 0) {
49: printf("Unexpected null command\n");
50: return;
51: }
52: }
53:
54: switch (cmd) {
55:
56: case 'Y':
57: debug = !debug;
58: break;
59:
60: case 'V':
61: version();
62: break;
63:
64: case 'a':
65: if (integ) {
66: cpstr(args, "l\n");
67: } else if (proc[0]) {
68: cpall(args, "T\n");
69: } else {
70: error("Bad arguments");
71: break;
72: }
73: goto setbrk;
74: break;
75:
76: case 'l':
77: setcur(1);
78: lastcom = NOCOM;
79: break;
80:
81: case 'T':
82: prfrx(1);
83: lastcom = NOCOM;
84: break;
85:
86: case 't':
87: prframe();
88: lastcom = NOCOM;
89: break;
90:
91: case 'e':
92: p = args;
93: if (*p == '\0') {
94: printf("%.8s() in \"%s\"\n",
95: curproc()->pname, curfile);
96: break;
97: }
98:
99: while (*p != '\0')
100: if (*p++ == '.') goto l1;
101: /* argument is procedure name */
102: procp = findproc(args);
103: if ((procp->pname[0] != '\0') && (procp->sfptr != badfile)) {
104: finit(adrtofilep(procp->paddr)->sfilename);
105: ffind(procp->lineno);
106: }
107: else printf("Can't find %s\n", args);
108: printf("%.8s() in \"%s\"\n", curproc()->pname, curfile);
109: lastcom = NOCOM;
110: break;
111:
112: l1: /* argument is filename */
113: finit(args);
114: printf("\"%s\"\n", curfile);
115: lastcom = NOCOM;
116: break;
117:
118: case 'p':
119: if (integ) ffind(integ);
120: fprint();
121: lastcom = PRCOM;
122: break;
123:
124: case 'q':
125: exit(0);
126:
127: case 'w':
128: if (integ) ffind(integ);
129: i = fline;
130: fback(WINDOW/2);
131: fprintn(WINDOW);
132: ffind(i);
133: lastcom = PRCOM;
134: break;
135:
136: case 'X':
137: prdebug();
138: break;
139:
140: case 'z':
141: if (integ) ffind(integ);
142: fprintn(WINDOW);
143: lastcom = PRCOM;
144: break;
145:
146: case '-':
147: fback(integ ? integ : 1);
148: fpargs();
149: lastcom = PRCOM;
150: break;
151:
152: case '+':
153: fforward(integ ? integ : 1);
154: fpargs();
155: lastcom = PRCOM;
156: break;
157:
158: case '\n':
159: switch (lastcom) {
160: case PRCOM:
161: fforward(1);
162: fprint();
163: break;
164: case DSCOM:
165: oaddr += oincr ? oincr : typetosize(otype, WORDSIZE);
166: printf("0x%x/ ", oaddr);
167: dispf((ADDR) oaddr, odesc,
168: oclass == N_RSYM ? oclass : N_GSYM, otype, 0, 0);
169: break;
170: }
171: break;
172:
173: case '\004':
174: fforward(1);
175: printf("\b");
176: fprintn(WINDOW);
177: lastcom = PRCOM;
178: break;
179:
180: case 'r':
181: if (args[0] == '\0') getargs();
182: case 'R':
183: signo = 0;
184: cpstr(oldargs, args);
185: if (debug) error("calling dopcs");
186: if (integ) cntval = integ;
187: if (!executing) {
188: executing = TRUE;
189: if (integ) cntval = integ;
190: dopcs('r');
191: executing = FALSE;
192: }
193: if (debug) error("exiting dopcs");
194: bkaddr = -1;
195: goto f1;
196:
197: case 'c':
198: signo = 0;
199: case 'C':
200: if (proc[0] != '\0' || integ != 0) {
201: dot = getaddr(proc, integ);
202: if (dot == -1) {
203: error("Cannot set temporary breakpoint");
204: break;
205: }
206: dopcs('b');
207: bkaddr = dot;
208: } else
209: bkaddr = -1;
210: integ = atoi(args);
211:
212: f1: if (debug) error("calling dopcs");
213: if (integ) cntval = integ;
214: dopcs('c');
215: if (debug) error("exiting dopcs");
216: if (bkaddr != -1) {
217: ADDR dotsave;
218: dotsave = dot;
219: dot = bkaddr;
220: dopcs('d');
221: dot = dotsave;
222: }
223: if (!signo) printf("Breakpoint");
224: printf(" at\n");
225: setcur(1);
226: lastcom = NOCOM;
227: break;
228:
229: case 'S':
230: case 's':
231: signo = 0;
232: integ = atoi(args);
233: singstep(integ ? integ : 1, cmd);
234: if (signo) printf("\n");
235: setcur(1);
236: lastcom = NOCOM;
237: break;
238:
239: case 'g':
240: if (pid == 0 || signo) {
241: error("Not stopped at breakpoint");
242: }
243: dot = getaddr(proc, integ);
244: if (dot == -1) {
245: error("Bad address");
246: break;
247: }
248: adrflg = 1;
249: integ = atoi(args);
250: if (integ) cntval = integ;
251: dopcs('c');
252: if (!signo) printf("Breakpoint");
253: printf(" at\n");
254: setcur(1);
255: lastcom = NOCOM;
256: break;
257:
258: case 'k':
259: if (scallx) {
260: userpc = dot = *(ADDR *)(((ADDR)&u)+PC) = pcs;
261: *(ADDR *)(((ADDR)&u)+FP) = fps;
262: *(ADDR *)(((ADDR)&u)+AP) = aps;
263: if (bkpts)
264: bkpts->flag = flagss;
265: scallx = 0;
266: error("Procedure killed");
267: longjmp(env, 0);
268: } else {
269: dopcs('k');
270: printf("\n");
271: lastcom = NOCOM;
272: break;
273: }
274:
275: case 'B':
276: prbkpt();
277: break;
278:
279: case 'b':
280: setbrk:
281: if (proc[0] == '\0' && integ == 0) {
282: integ = fline;
283: }
284: dot = getaddr(proc,integ);
285: if (dot == -1 || dot == 0) {
286: error("Cannot set breakpoint");
287: break;
288: }
289: dopcs('b');
290: s = " b\n";
291: s[1] = cmd;
292: printbkpt(s, adrtoprocp(dot)->pname,
293: adrtolineno(dot));
294: break;
295:
296: case 'd':
297: if (proc[0] == '\0' && integ == 0) {
298: idbkpt();
299: break;
300: }
301: dot = getaddr(proc,integ);
302: if (dot == -1) {
303: error("Non existent breakpoint");
304: break;
305: }
306: dopcs('d');
307: break;
308:
309: case 'D':
310: dabkpt();
311: error("All breakpoints deleted");
312: break;
313:
314: case 'm':
315: addr = varaddr(proc[0] ? proc : curproc()->pname, var);
316: printf("stopped with value %d\n", monex(addr, 'd'));
317: setcur(1);
318: lastcom = NOCOM;
319: break;
320:
321: case '/':
322: if (var[0] == '.' && var[1] == '\0') {
323: if (integ == 0) integ = oaddr;
324: dispf((ADDR) integ, args[0] ? args : odesc,
325: oclass == N_RSYM ? oclass : N_GSYM, otype, 0, 0);
326: oaddr = integ;
327: } else
328: if (integ && (var[0] == '\0')) {
329: dispf((ADDR) integ, args, N_GSYM, 0, 0, 0);
330: oaddr = integ;
331: cpstr(odesc, args);
332: oclass = N_GSYM;
333: otype = 0;
334: } else
335: dispvar(proc, var, args);
336: lastcom = DSCOM;
337: break;
338:
339: case '=':
340: if (var[0] == '\0') {
341: if (proc[0]) {
342: addr = getaddr(proc, integ);
343: if (addr == -1) {
344: error("Unknown address");
345: break;
346: }
347: }
348: else
349: addr = integ;
350: dispf(addr, args[0] ? args : "x", 0, -1, 0, 0);
351: } else
352: findvar(proc, var, args[0] ? args : "x", 2);
353: break;
354:
355: case '!':
356: if (var[0] == '\0')
357: addr = getaddr(proc, integ);
358: else
359: addr = varaddr(proc, var);
360: if (addr == -1)
361: error("Unknown variable");
362: else {
363: if (number(args[0]) || eqany(args[0], ".-")) {
364: char *p;
365: double atof();
366: union {
367: struct{
368: int w1, w2;
369: };
370: struct {
371: double d;
372: };
373: } dbl;
374:
375: p = (args[0] == '-') ? args+1 : args;
376: for (; *p != '.' && *p != 'e'; p++) {
377: if (!number(*p)) goto l2;
378: }
379: dbl.d = atof(args);
380: putval(addr, 'd', dbl.w1);
381: if (typetodesc(sl_type,0)[0] == 'g')
382: putval(addr+WORDSIZE, 'd', dbl.w2);
383: break;
384: }
385: l2: if (sl_class == N_RSYM && addr < 16)
386: putreg(addr,typetodesc(sl_type,subflag)[0],
387: argvalue(args));
388: else
389: putval(addr,typetodesc(sl_type,subflag)[0],
390: argvalue(args));
391: }
392: lastcom = NOCOM;
393: break;
394:
395: case '"':
396: printf(args);
397: break;
398: }
399: }
400:
401: fpargs() {
402: register int i;
403:
404: switch(args[0]) {
405: case 'p':
406: case '\0':
407: fprint();
408: break;
409: case 'w':
410: i = fline;
411: fback(WINDOW/2);
412: fprintn(WINDOW);
413: ffind(i);
414: break;
415: case 'z':
416: fprintn(WINDOW);
417: break;
418: }
419: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.