[unix-history] / usr / src / cmd / sdb / docomm.c

#include <signal.h>
#include "head.h"
#include <a.out.h>

struct user u;
L_INT 	cntval;
INT	signo;
INT	adrflg;
INT	pid;
ADDR	userpc;
char	*s;
enum	{NOCOM, PRCOM, DSCOM} lastcom;

docommand() {
	register char	*p;
	register int	i;
	register ADDR	addr, bkaddr;
	struct proct 	*procp;
	
	cntval = 1;
	adrflg = 0;
	errflg = 0;

	if (scallf) {
		doscall();
		setcur(1);
		lastcom = NOCOM;
		return;
	}
	
	if (reflag) {  /* search for regular expression */
		dore();
		lastcom = PRCOM;
		return;
	}
	
	if (cmd == '\0') {
		if (integ != 0 && var[0] != '\0') {
			error("Invalid command (1)");
			return;
		}
		if (integ != 0) { /* print line number */
			ffind(integ);
			fprint();
			lastcom = PRCOM;
			return;
		}
		if (var[0] != 0) {
			printf("Unexpected null command\n");
			return;
		}
	}
		
	switch (cmd) {
	
	case 'Y':
		debug = !debug;
		break;

	case 'V':
		version();
		break;

	case 'a':
		if (integ) {
			cpstr(args, "l\n");
		} else if (proc[0]) {
			cpall(args, "T\n");
		} else {
			error("Bad arguments");
			break;
		}
		goto setbrk;
		break;	

	case 'l':
		setcur(1);
		lastcom = NOCOM;
		break;
		
	case 'T':
		prfrx(1);
		lastcom = NOCOM;
		break;
		
	case 't':
		prframe();
		lastcom = NOCOM;
		break;
		
	case 'e':
		p = args;
		if (*p == '\0') {
			printf("%.8s() in \"%s\"\n",
				curproc()->pname, curfile);
			break;
		}

		while (*p != '\0')
			if (*p++ == '.') goto l1;
		/* argument is procedure name */
		procp = findproc(args);
		if ((procp->pname[0] != '\0') && (procp->sfptr != badfile)) {
			finit(adrtofilep(procp->paddr)->sfilename);
			ffind(procp->lineno);
		}
		else printf("Can't find %s\n", args);
		printf("%.8s() in \"%s\"\n", curproc()->pname, curfile);
		lastcom = NOCOM;
		break;
		
	l1:	/* argument is filename */
		finit(args);
		printf("\"%s\"\n", curfile);
		lastcom = NOCOM;
		break;
		
	case 'p':
		if (integ) ffind(integ);
		fprint();
		lastcom = PRCOM;
		break;
		
	case 'q':
		exit(0);
		
	case 'w':
		if (integ) ffind(integ);
		i = fline;
		fback(WINDOW/2);
		fprintn(WINDOW);
		ffind(i);
		lastcom = PRCOM;
		break;
		
	case 'X':
		prdebug();
		break;

	case 'z':
		if (integ) ffind(integ);
		fprintn(WINDOW);
		lastcom = PRCOM;
		break;

	case '-':
		fback(integ ? integ : 1);
		fpargs();
		lastcom = PRCOM;
		break;

	case '+':
		fforward(integ ? integ : 1);
		fpargs();
		lastcom = PRCOM;
		break;

	case '\n':
		switch (lastcom) {
		case PRCOM:
			fforward(1);
			fprint();
			break;
		case DSCOM:
			oaddr += oincr ? oincr : typetosize(otype, WORDSIZE);
			printf("0x%x/ ", oaddr);
			dispf((ADDR) oaddr, odesc,
			    oclass == N_RSYM ? oclass : N_GSYM, otype, 0, 0);
			break;
		}
		break;

	case '\004':
		fforward(1);
		printf("\b");
		fprintn(WINDOW);
		lastcom = PRCOM;
		break;

	case 'r':
		if (args[0] == '\0') getargs();
	case 'R':
		signo = 0;
		cpstr(oldargs, args);
		if (debug) error("calling dopcs");
		if (integ) cntval = integ;
		if (!executing) {
			executing = TRUE;
			if (integ) cntval = integ;
			dopcs('r');
			executing = FALSE;
		}
		if (debug) error("exiting dopcs");
		bkaddr = -1;
		goto f1;

	case 'c':
		signo = 0;
	case 'C':
		if (proc[0] != '\0' || integ != 0) {
			dot = getaddr(proc, integ);
			if (dot == -1) {
				error("Cannot set temporary breakpoint");
				break;
			}
			dopcs('b');
			bkaddr = dot;
		} else
			bkaddr = -1;
		integ = atoi(args);

f1:		if (debug) error("calling dopcs");
		if (integ) cntval = integ;
		dopcs('c');
		if (debug) error("exiting dopcs");
		if (bkaddr != -1) {
			ADDR dotsave;
			dotsave = dot;
			dot = bkaddr;
			dopcs('d');
			dot = dotsave;
		}
		if (!signo) printf("Breakpoint");
		printf(" at\n");
		setcur(1);
		lastcom = NOCOM;
		break;
		
	case 'S':
	case 's':
		signo = 0;
		integ = atoi(args);
		singstep(integ ? integ : 1, cmd);
		if (signo) printf("\n");
		setcur(1);
		lastcom = NOCOM;
		break;
		
	case 'g':
		if (pid == 0  ||  signo) {
			error("Not stopped at breakpoint");
		}
		dot = getaddr(proc, integ);
		if (dot == -1) {
			error("Bad address");
			break;
		}
		adrflg = 1;
		integ = atoi(args);
		if (integ) cntval = integ;
		dopcs('c');
		if (!signo) printf("Breakpoint");
		printf(" at\n");
		setcur(1);
		lastcom = NOCOM;
		break;

	case 'k':
		if (scallx) {
	 		userpc = dot = *(ADDR *)(((ADDR)&u)+PC) = pcs;
	 		*(ADDR *)(((ADDR)&u)+FP) = fps;
	 		*(ADDR *)(((ADDR)&u)+AP) = aps;
			if (bkpts)
				bkpts->flag = flagss;
			scallx = 0;
			error("Procedure killed");
			longjmp(env, 0);
		} else {
			dopcs('k');
			printf("\n");
			lastcom = NOCOM;
			break;
		}

	case 'B':
		prbkpt();
		break;

	case 'b':
	setbrk:
		if (proc[0] == '\0' && integ == 0) {
			integ = fline;
		}
		dot = getaddr(proc,integ);
		if (dot == -1 || dot == 0) {
			error("Cannot set breakpoint");
			break;
		}
		dopcs('b');
		s = " b\n";
		s[1] = cmd;
		printbkpt(s, adrtoprocp(dot)->pname,
			adrtolineno(dot));
		break;
		
	case 'd':
		if (proc[0] == '\0' && integ == 0) {
			idbkpt();
			break;
		}
		dot = getaddr(proc,integ);
		if (dot == -1) {
			error("Non existent breakpoint");
			break;
		}
		dopcs('d');
		break;
		
	case 'D':
		dabkpt();
		error("All breakpoints deleted");
		break;

	case 'm':
		addr = varaddr(proc[0] ? proc : curproc()->pname, var);
		printf("stopped with value %d\n", monex(addr, 'd'));
		setcur(1);
		lastcom = NOCOM;
		break;
		
	case '/':
		if (var[0] == '.' && var[1] == '\0') {
			if (integ == 0) integ = oaddr;
			dispf((ADDR) integ, args[0] ? args : odesc,
			    oclass == N_RSYM ? oclass : N_GSYM, otype, 0, 0);
			oaddr = integ;
		} else
		if (integ && (var[0] == '\0')) {
			dispf((ADDR) integ, args, N_GSYM, 0, 0, 0);
			oaddr = integ;
			cpstr(odesc, args);
			oclass = N_GSYM;
			otype = 0;
		} else
			dispvar(proc, var, args);
		lastcom = DSCOM;
		break;
		
	case '=':
		if (var[0] == '\0') {
			if (proc[0]) {
				addr = getaddr(proc, integ);
				if (addr == -1) {
					error("Unknown address");
					break;
				}
			}
			else
				addr = integ;
			dispf(addr, args[0] ? args : "x", 0, -1, 0, 0);
		} else 
			findvar(proc, var, args[0] ? args : "x", 2);
		break;

	case '!':
		if (var[0] == '\0')
			addr = getaddr(proc, integ);
		else
			addr = varaddr(proc, var);
		if (addr == -1) 
			error("Unknown variable");
		else {
			if (number(args[0]) || eqany(args[0], ".-")) {
				char *p;
				double atof();
				union {
					struct{
						int w1, w2;
					};
					struct {
						double d;
					};
				} dbl;

				p = (args[0] == '-') ? args+1 : args;
				for (; *p != '.' && *p != 'e'; p++) {
					if (!number(*p)) goto l2;
				}
				dbl.d = atof(args);
				putval(addr, 'd', dbl.w1);
				if (typetodesc(sl_type,0)[0] == 'g')
					putval(addr+WORDSIZE, 'd', dbl.w2);
				break;
			}
l2: 			if (sl_class == N_RSYM && addr < 16)
				putreg(addr,typetodesc(sl_type,subflag)[0],
						argvalue(args));
			else
				putval(addr,typetodesc(sl_type,subflag)[0],
						argvalue(args));
		}
		lastcom = NOCOM;
		break;

	case '"':
		printf(args);
		break;
	}
}

fpargs() {
	register int i;
	
	switch(args[0]) {
	case 'p':
	case '\0':
		fprint();
		break;
case 'w':
		i = fline;
		fback(WINDOW/2);
		fprintn(WINDOW);
		ffind(i);
		break;
	case 'z':
		fprintn(WINDOW);
		break;
	}
}
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	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	}