Commit | Line | Data |
---|---|---|
b4484850 HK |
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 | singstep(integ ? integ : 1, cmd); | |
233 | if (signo) printf("\n"); | |
234 | setcur(1); | |
235 | lastcom = NOCOM; | |
236 | break; | |
237 | ||
238 | case 'g': | |
239 | if (pid == 0 || signo) { | |
240 | error("Not stopped at breakpoint"); | |
241 | } | |
242 | dot = getaddr(proc, integ); | |
243 | if (dot == -1) { | |
244 | error("Bad address"); | |
245 | break; | |
246 | } | |
247 | adrflg = 1; | |
248 | integ = atoi(args); | |
249 | if (integ) cntval = integ; | |
250 | dopcs('c'); | |
251 | if (!signo) printf("Breakpoint"); | |
252 | printf(" at\n"); | |
253 | setcur(1); | |
254 | lastcom = NOCOM; | |
255 | break; | |
256 | ||
257 | case 'k': | |
258 | if (scallx) { | |
259 | userpc = dot = *(ADDR *)(((ADDR)&u)+PC) = pcs; | |
260 | *(ADDR *)(((ADDR)&u)+FP) = fps; | |
261 | *(ADDR *)(((ADDR)&u)+AP) = aps; | |
262 | if (bkpts) | |
263 | bkpts->flag = flagss; | |
264 | scallx = 0; | |
265 | error("Procedure killed"); | |
266 | longjmp(env, 0); | |
267 | } else { | |
268 | dopcs('k'); | |
269 | printf("\n"); | |
270 | lastcom = NOCOM; | |
271 | break; | |
272 | } | |
273 | ||
274 | case 'B': | |
275 | prbkpt(); | |
276 | break; | |
277 | ||
278 | case 'b': | |
279 | setbrk: | |
280 | if (proc[0] == '\0' && integ == 0) { | |
281 | integ = fline; | |
282 | } | |
283 | dot = getaddr(proc,integ); | |
284 | if (dot == -1 || dot == 0) { | |
285 | error("Cannot set breakpoint"); | |
286 | break; | |
287 | } | |
288 | dopcs('b'); | |
289 | s = " b\n"; | |
290 | s[1] = cmd; | |
291 | printbkpt(s, adrtoprocp(dot)->pname, | |
292 | adrtolineno(dot)); | |
293 | break; | |
294 | ||
295 | case 'd': | |
296 | if (proc[0] == '\0' && integ == 0) { | |
297 | idbkpt(); | |
298 | break; | |
299 | } | |
300 | dot = getaddr(proc,integ); | |
301 | if (dot == -1) { | |
302 | error("Non existent breakpoint"); | |
303 | break; | |
304 | } | |
305 | dopcs('d'); | |
306 | break; | |
307 | ||
308 | case 'D': | |
309 | dabkpt(); | |
310 | error("All breakpoints deleted"); | |
311 | break; | |
312 | ||
313 | case 'm': | |
314 | addr = varaddr(proc[0] ? proc : curproc()->pname, var); | |
315 | printf("stopped with value %d\n", monex(addr, 'd')); | |
316 | setcur(1); | |
317 | lastcom = NOCOM; | |
318 | break; | |
319 | ||
320 | case '/': | |
321 | if (var[0] == '.' && var[1] == '\0') { | |
322 | if (integ == 0) integ = oaddr; | |
323 | dispf((ADDR) integ, args[0] ? args : odesc, | |
324 | oclass == N_RSYM ? oclass : N_GSYM, otype, 0, 0); | |
325 | oaddr = integ; | |
326 | } else | |
327 | if (integ && (var[0] == '\0')) { | |
328 | dispf((ADDR) integ, args, N_GSYM, 0, 0, 0); | |
329 | oaddr = integ; | |
330 | cpstr(odesc, args); | |
331 | oclass = N_GSYM; | |
332 | otype = 0; | |
333 | } else | |
334 | dispvar(proc, var, args); | |
335 | lastcom = DSCOM; | |
336 | break; | |
337 | ||
338 | case '=': | |
339 | if (var[0] == '\0') { | |
340 | if (proc[0]) { | |
341 | addr = getaddr(proc, integ); | |
342 | if (addr == -1) { | |
343 | error("Unknown address"); | |
344 | break; | |
345 | } | |
346 | } | |
347 | else | |
348 | addr = integ; | |
349 | dispf(addr, args[0] ? args : "x", 0, -1, 0, 0); | |
350 | } else | |
351 | findvar(proc, var, args[0] ? args : "x", 2); | |
352 | break; | |
353 | ||
354 | case '!': | |
355 | if (var[0] == '\0') | |
356 | addr = getaddr(proc, integ); | |
357 | else | |
358 | addr = varaddr(proc, var); | |
359 | if (addr == -1) | |
360 | error("Unknown variable"); | |
361 | else { | |
362 | if (number(args[0]) || eqany(args[0], ".-")) { | |
363 | char *p; | |
364 | double atof(); | |
365 | union { | |
366 | struct{ | |
367 | int w1, w2; | |
368 | }; | |
369 | struct { | |
370 | double d; | |
371 | }; | |
372 | } dbl; | |
373 | ||
374 | p = (args[0] == '-') ? args+1 : args; | |
375 | for (; *p != '.' && *p != 'e'; p++) { | |
376 | if (!number(*p)) goto l2; | |
377 | } | |
378 | dbl.d = atof(args); | |
379 | putval(addr, 'd', dbl.w1); | |
380 | if (typetodesc(sl_type,0)[0] == 'g') | |
381 | putval(addr+WORDSIZE, 'd', dbl.w2); | |
382 | break; | |
383 | } | |
384 | l2: if (sl_class == N_RSYM && addr < 16) | |
385 | putreg(addr,typetodesc(sl_type,subflag)[0], | |
386 | argvalue(args)); | |
387 | else | |
388 | putval(addr,typetodesc(sl_type,subflag)[0], | |
389 | argvalue(args)); | |
390 | } | |
391 | lastcom = NOCOM; | |
392 | break; | |
393 | ||
394 | case '"': | |
395 | printf(args); | |
396 | break; | |
397 | } | |
398 | } | |
399 | ||
400 | fpargs() { | |
401 | register int i; | |
402 | ||
403 | switch(args[0]) { | |
404 | case 'p': | |
405 | case '\0': | |
406 | fprint(); | |
407 | break; | |
408 | case 'w': | |
409 | i = fline; | |
410 | fback(WINDOW/2); | |
411 | fprintn(WINDOW); | |
412 | ffind(i); | |
413 | break; | |
414 | case 'z': | |
415 | fprintn(WINDOW); | |
416 | break; | |
417 | } | |
418 | } |