![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xeq.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 xeq.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / sdb |
1.1 root 1: #include "head.h"
2: #include <a.out.h>
3: struct user u;
4: #include <stdio.h>
5: INT signo;
6: INT adrflg;
7: INT pid;
8: ADDR userpc;
9: L_INT cntval;
10:
11:
12: /* service routines for sub process control */
13:
14:
15: /*
16: * single step until loc with descriptor format d is modified
17: * return its new value.
18: */
19: monex(loc, d)
20: ADDR loc; char d; {
21: register ADDR oldval;
22:
23: oldval = getval(loc, d);
24: do {
25: subpcs('s');
26: } while (oldval == getval(loc, d));
27: return(getval(loc, d));
28: }
29:
30: /* single step count source stmts */
31: singstep(count, cmd)
32: char cmd; {
33: register int thisline, curline;
34: register struct proct *thisproc;
35:
36: if (sdbttym.sg_flags != userttym.sg_flags)
37: stty(2, &userttym);
38: dot = *(ADDR *) (((ADDR) &u) + PC);
39: thisproc = adrtoprocp(dot);
40: thisline = adrtolineno(dot);
41: if (count == 0) count = 1;
42: for(; count; count--) {
43: do {
44: if (cmd == 'S') {
45: dot = *(ADDR *) (((ADDR) &u) + PC);
46: if ((get(dot,ISP) & 0xff) == 0xfb){ /* calls */
47: int retaddr;
48: subpcs('s');
49: retaddr =
50: *(ADDR *) (((ADDR) &u) + USP) + 16;
51: retaddr = dot = get(retaddr, DSP);
52: subpcs('b');
53: subpcs('c');
54: dot = retaddr;
55: subpcs('d');
56: dot = *(ADDR *) (((ADDR) &u) + PC);
57: if (retaddr != dot && signo == 0) {
58: gtty(2, &userttym);
59: if (sdbttym.sg_flags !=
60: userttym.sg_flags)
61: stty(2, &sdbttym);
62: printf("Breakpoint at \n");
63: return;
64: }
65: continue;
66: }
67: }
68:
69: subpcs('s');
70: dot = *(ADDR *) (((ADDR) &u) + PC);
71: curline = adrtolineno(dot);
72: } while (!signo &&
73: ((thisproc == adrtoprocp(dot) && thisline == curline) ||
74: curline == -1));
75: gtty(2, &userttym);
76: if (sdbttym.sg_flags != userttym.sg_flags)
77: stty(2, &sdbttym);
78: if (signo) return;
79: }
80: }
81:
82: doscall() {
83: int subargs[NUMARGS]; /* subargs[0] = address,
84: subargs[1] = number of arguments
85: subargs[2:NUMARGS] = actual arguments */
86: union {
87: struct {
88: int w[128-NUMARGS];
89: };
90: struct {
91: char c[4*(128-NUMARGS)];
92: };
93: }substr;
94:
95: register int i, numchars, *subargp;
96: register char ch;
97: ADDR straddr, adr, praddr;
98: ADDR j;
99:
100: praddr = extaddr(proc);
101: if (praddr == -1) {
102: printf("Cannot find %s\n", proc);
103: return;
104: }
105: straddr = extaddr("_dbargs");
106: if (straddr == -1) {
107: error("Program not loaded with -lg");
108: return;
109: }
110:
111: numchars = 0;
112: subargp = subargs;
113: argsp++;
114: *subargp++ = praddr;
115: subargp++;
116:
117: for (i=0; i<NUMARGS - 2; i++) { /* process an argument */
118: ch = *argsp;
119: if (ch == '\'') {
120: *subargp++ = *(argsp+1);
121: argsp += 2;
122: } else if (ch == '"') {
123: *subargp++ = straddr + sizeof subargs + numchars;
124: argsp++;
125: for (;;) {
126: ch = *argsp++;
127: if (ch == '\\') {
128: switch(ch = *argsp++) {
129: case 'r':
130: ch = '\015';
131: break;
132: case 'n':
133: ch = '\012';
134: break;
135: case '\\':
136: ch = '\\';
137: break;
138: }
139: }
140: substr.c[numchars++] = ch;
141: if (ch == '"') {
142: substr.c[numchars-1] = '\0';
143: break;
144: }
145: if (ch == '\0') {
146: error("Unterminated string constant");
147: return;
148: }
149: if (numchars > sizeof substr.c) {
150: error("Too many string constants");
151: return;
152: }
153: }
154: } else if ((ch >= '0' && ch <= '9') || ch == '-') {
155: *subargp++ = readint(&argsp);
156: } else if ((ch >= 'a' && ch <= 'z') ||
157: (ch >= 'A' && ch <= 'Z') || ch == '_') {
158: cpname(var, argsp);
159: j = varaddr(curproc()->pname, var);
160: if (j == -1) {
161: return;
162: }
163: *subargp++ =
164: sl_class == N_RSYM ?
165: *(ADDR *)(((ADDR) &u) + R0 + (WORDSIZE)*j) :
166: getval(j, typetodesc(sl_type, 0)[0]);
167: do {
168: argsp++;
169: } while (varchar(*argsp) || number(*argsp));
170: } else if (ch != ')') {
171: printf("Unexpected character %c\n", ch);
172: return;
173: }
174:
175: do {
176: ch = *argsp++;
177: } while(ch == ' ');
178: if (ch == ')') {
179: if (scallx == 0) {
180: scallx = 1;
181: pcs = *(ADDR *)(((ADDR)&u)+PC);
182: fps = *(ADDR *)(((ADDR)&u)+FP);
183: aps = *(ADDR *)(((ADDR)&u)+AP);
184: if (bkpts = scanbkpt(userpc)) {
185: if (flagss = bkpts->flag) {
186: bkpts->flag = BKPTSET;
187: }
188: }
189: }
190: dot = *(ADDR *)(((ADDR)&u)+PC) = extaddr("_dbsubc");
191: if (dot == -1) {
192: error("Internal error - cannot find _dbsubc");
193: return;
194: }
195: adrflg = 1;
196: cntval = 1;
197: if (pid == 0 || signo) subpcs('r');
198: subargs[1] = (subargp - subargs) - 2;
199: adr = straddr;
200: for (j=0; j<=(subargp-subargs); j++) {
201: put(adr, DSP, subargs[j]);
202: adr += WORDSIZE;
203: }
204: adr = straddr + sizeof subargs;
205: for (j=0; j<(numchars+WORDSIZE-1)/WORDSIZE; j++) {
206: put(adr, DSP, substr.w[j]);
207: adr += WORDSIZE;
208: }
209: dschar = *argsp++;
210: errflg = 0;
211: dopcs('c');
212: if (!signo) printf("Breakpoint");
213: printf(" at\n");
214: return;
215: }
216: while (*argsp == ' ' || *argsp == ',')
217: argsp++;
218: }
219:
220: error ("Too many arguments");
221:
222: }
223:
224:
225: /* get arguments from core file, place them in args */
226: getargs() {
227: struct proct *procp;
228: ADDR p, av;
229: int ac, i;
230: char *argsp = args;
231: union {
232: struct {
233: char c[WORDSIZE];
234: };
235: struct {
236: int w;
237: };
238: struct {
239: float f;
240: }
241: } word;
242:
243: if ((procp = initframe()) == badproc) goto old1;
244: do {
245: if (eqstr("main", procp->pname))
246: goto fnd;
247: } while ((procp = nextframe()) != badproc);
248:
249: old1: cpstr(args, oldargs);
250: printf("%s %s\n", symfil, args);
251: return;
252:
253: fnd: ac = get(argp, DSP);
254: if ((ac == 0) || (ac & 0xff)) goto old1;
255: ac = get(argp+4, DSP);
256: av = (ADDR) get(argp+8, DSP);
257:
258: av += WORDSIZE;
259: ac--;
260:
261: for (; ac; ac--) {
262: p = (ADDR) get(av, DSP);
263: av += WORDSIZE;
264: for (;;) {
265: word.w = get(p, DSP);
266: for (i=0; i<WORDSIZE; i++) {
267: if (word.c[i] == '\0') goto l1;
268: *argsp++ = word.c[i];
269: }
270: p += WORDSIZE;
271: }
272: l1: *argsp++ = ' ';
273: }
274: *argsp == '\0';
275: printf("%s %s\n", symfil, args);
276: return;
277:
278:
279: }
280:
281: dopcs(c)
282: char c; {
283: if (c != 'r' && c != 'R' && sdbttym.sg_flags != userttym.sg_flags)
284: stty(2, &userttym);
285: subpcs(c);
286: gtty(2, &userttym);
287: if (sdbttym.sg_flags != userttym.sg_flags)
288: stty(2, &sdbttym);
289:
290: if (eqany(c, "cCsS") &&
291: *(ADDR *)(((ADDR)&u)+PC) == extaddr("_dbsubn")) {
292: if (dschar == '/') {
293: dispf((ADDR) 0, *argsp ? argsp : "d", N_RSYM, 0, 0);
294: }
295: else
296: printf("Procedure returned normally\n");
297: userpc = dot = *(ADDR *)(((ADDR)&u)+PC) = pcs;
298: *(ADDR *)(((ADDR)&u)+FP) = fps;
299: *(ADDR *)(((ADDR)&u)+AP) = aps;
300: if (bkpts)
301: bkpts->flag = flagss;
302: scallx = 0;
303: longjmp(env, 0);
304: }
305: }
306:
307: /* execute commands from a breakpoint */
308: acommand(cmds)
309: char *cmds; {
310: char *p = cmds;
311: int endflg = 0;
312:
313: setcur(0);
314: do { /* process a command */
315: for (;;) {
316: if (*p == ';') {
317: *p = '\n';
318: break;
319: }
320: if (*p == '\n') {
321: endflg++;
322: break;
323: }
324: p++;
325: }
326: if (decode(cmds) == 1) {
327: printf("Bad command: ");
328: do {
329: printf("%c", *cmds);
330: } while (*cmds++ != '\n');
331: return;
332: }
333: docommand();
334: p = cmds = p + 1;
335: } while (!endflg);
336: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.