[unix-history] / .ref-5cb41021d721f4e0ac572d592613f963e495d1ff / usr / src / old / sdb / docomm.c

static	char sccsid[] = "@(#)docomm.c 4.1 %G%";
#include <signal.h>
#include "head.h"
#include <a.out.h>
#include <stab.h>

struct user u;
L_INT 	cntval;
INT	signo;
INT	adrflg;
INT	pid;
ADDR	userpc;
char	*s;
enum	{NOCOM, PRCOM, DSCOM, DSICOM} lastcom;
		/* last command: nothing noteworthy, print source,
			display variable, display instruction */

docommand() {
	register char	*p;
	register int	i;
	register ADDR	addr, bkaddr;
	struct proct 	*procp;
	char s[4];
	
	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 'M':
		if (args[0]) {
			setmap(args);
		} else {
			printmap("? map", &txtmap);
			printmap("/ map", &datmap);
		}
		break;

	case 'x':
		printregs();
		break;

	case 'X':
		printpc();
		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') {
#ifndef FLEXNAMES
			printf("%.16s() in \"%s\"\n",
				curproc()->pname, curfile);
#else
			printf("%s() in \"%s\"\n",
				curproc()->pname, curfile);
#endif
			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);
#ifndef FLEXNAMES
		printf("%.16s() in \"%s\"\n", curproc()->pname, curfile);
#else
		printf("%s() in \"%s\"\n", curproc()->pname, curfile);
#endif
		lastcom = PRCOM;
		break;
		
	l1:	/* argument is filename */
		finit(args);
		printf("\"%s\"\n", curfile);
		lastcom = PRCOM;
		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 'Q':
		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, DSP);
			break;
		case DSICOM:
			dot += oincr;
			prisploc();
			dispi(dot, odesc, N_GSYM, 0, 0);
			break;
		}
		break;

	case '\004':
		if (!isatty(0))
			exit(0);
		switch (lastcom) {
		case PRCOM:
			fforward(1);
			printf("\b");
			fprintn(WINDOW);
			lastcom = PRCOM;
			break;
		case DSICOM:
			printf("\b");
			for (i=0; i<WINDOW; i++) {
				dot += oincr;
				prisploc();
				if (dispi(dot, odesc, N_GSYM, 0, 0) == -1)
					break;
			}
			break;
		case DSCOM:
			printf("\b");
			for (i=0; i<WINDOW; i++) {
				oaddr += oincr ?
					oincr : typetosize(otype, WORDSIZE);
				printf("0x%x/ ", oaddr);
				if (dispf((ADDR) oaddr, odesc,
					oclass == N_RSYM ? oclass :
					N_GSYM, otype, 0, 0, DSP) == -1)
					break;
			}
			break;
		default:
			printf("\n");
		}
		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) {
			setdot();
			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");
			break;
		}
		setdot();
		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;
		}
		setdot();
		if (dot == -1 || dot == 0) {
			error("Cannot set breakpoint");
			break;
		}
		dopcs('b');
		s[0] = ' ';
		s[1] = cmd;
		s[2] = '\n';
		s[3] = 0;
		s[1] = cmd;
		printbkpt(s, adrtoprocp(dot), dot);
		break;
		
	case 'd':
		if (proc[0] == '\0' && integ == 0) {
			idbkpt();
			break;
		}
		setdot();
		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'))
			setdot();
		if (errflg) {
			error(errflg);
			break;
		}
		prisploc();
		dispi(dot, args[0] ? args : "i", N_GSYM, 0, 0);
		lastcom = DSICOM;
		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, DSP);
			oaddr = integ;
		} else
		if (integ && (var[0] == '\0')) {
			dispf((ADDR) integ, args, N_GSYM, 0, 0, 0, DSP);
			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, DSP);
		} 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;
					} ww;
					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.ww.w1);
				if (typetodesc(sl_type,0)[0] == 'g')
					putval(addr+WORDSIZE, 'd', dbl.ww.w2);
				break;
			}
l2:			if (percentflag)
				*(ADDR *)(((ADDR)&u)+addr) = argvalue(args);
			else 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;
	}
}

MSG	BADTXT;
/* Used by a, b, c, C, d and g commands to find linenumber */
setdot() {
	if (ncolonflag) {
		dot = integ;
		get(dot, ISP);
		if (errflg)
			dot = -1;
	} else {
		dot = getaddr(proc, integ);
		if (dot == -1)
			errflg = "Bad line number";
	}
}
Commit	Line	Data
c40fd71a BJ	1	static char sccsid[] = "@(#)docomm.c 4.1 %G%";
	2	#include <signal.h>
	3	#include "head.h"
	4	#include <a.out.h>
	5	#include <stab.h>
	6
	7	struct user u;
	8	L_INT cntval;
	9	INT signo;
	10	INT adrflg;
	11	INT pid;
	12	ADDR userpc;
	13	char *s;
	14	enum {NOCOM, PRCOM, DSCOM, DSICOM} lastcom;
	15	/* last command: nothing noteworthy, print source,
	16	display variable, display instruction */
	17
	18	docommand() {
	19	register char *p;
	20	register int i;
	21	register ADDR addr, bkaddr;
	22	struct proct *procp;
	23	char s[4];
	24
	25	cntval = 1;
	26	adrflg = 0;
	27	errflg = 0;
	28
	29	if (scallf) {
	30	doscall();
	31	setcur(1);
	32	lastcom = NOCOM;
	33	return;
	34	}
	35
	36	if (reflag) { /* search for regular expression */
	37	dore();
	38	lastcom = PRCOM;
	39	return;
	40	}
	41
	42	if (cmd == '\0') {
	43	if (integ != 0 && var[0] != '\0') {
	44	error("Invalid command (1)");
	45	return;
	46	}
	47	if (integ != 0) { /* print line number */
	48	ffind(integ);
	49	fprint();
	50	lastcom = PRCOM;
	51	return;
	52	}
	53	if (var[0] != 0) {
	54	printf("Unexpected null command\n");
	55	return;
	56	}
	57	}
	58
	59	switch (cmd) {
	60
	61	case 'Y':
	62	debug = !debug;
	63	break;
	64
65	case 'V':
66	version();
67	break;
68
69	case 'M':
70	if (args[0]) {
71	setmap(args);
72	} else {
73	printmap("? map", &txtmap);
74	printmap("/ map", &datmap);
75	}
76	break;
77
78	case 'x':
79	printregs();
80	break;
81
82	case 'X':
83	printpc();
84	break;
85
86	case 'a':
87	if (integ) {
88	cpstr(args, "l\n");
89	} else if (proc[0]) {
90	cpall(args, "T\n");
91	} else {
92	error("Bad arguments");
93	break;
94	}
95	goto setbrk;
96	break;
97
98	case 'l':
99	setcur(1);
100	lastcom = NOCOM;
101	break;
102
103	case 'T':
104	prfrx(1);
105	lastcom = NOCOM;
106	break;
107
108	case 't':
109	prframe();
110	lastcom = NOCOM;
111	break;
112
113	case 'e':
114	p = args;
115	if (*p == '\0') {
116	#ifndef FLEXNAMES
117	printf("%.16s() in \"%s\"\n",
118	curproc()->pname, curfile);
119	#else
120	printf("%s() in \"%s\"\n",
121	curproc()->pname, curfile);
122	#endif
123	break;
124	}
125
126	while (*p != '\0')
127	if (*p++ == '.') goto l1;
128	/* argument is procedure name */
129	procp = findproc(args);
130	if ((procp->pname[0] != '\0') && (procp->sfptr != badfile)) {
131	finit(adrtofilep(procp->paddr)->sfilename);
132	ffind(procp->lineno);
133	}
134	else printf("Can't find %s\n", args);
135	#ifndef FLEXNAMES
136	printf("%.16s() in \"%s\"\n", curproc()->pname, curfile);
137	#else
138	printf("%s() in \"%s\"\n", curproc()->pname, curfile);
139	#endif
140	lastcom = PRCOM;
141	break;
142
143	l1: /* argument is filename */
144	finit(args);
145	printf("\"%s\"\n", curfile);
146	lastcom = PRCOM;
147	break;
148
149	case 'p':
150	if (integ) ffind(integ);
151	fprint();
152	lastcom = PRCOM;
153	break;
154
155	case 'q':
156	exit(0);
157
158	case 'w':
159	if (integ) ffind(integ);
160	i = fline;
161	fback(WINDOW/2);
162	fprintn(WINDOW);
163	ffind(i);
164	lastcom = PRCOM;
165	break;
166
167	case 'Q':
168	prdebug();
169	break;
170
171	case 'z':
172	if (integ) ffind(integ);
173	fprintn(WINDOW);
174	lastcom = PRCOM;
175	break;
176
177	case '-':
178	fback(integ ? integ : 1);
179	fpargs();
180	lastcom = PRCOM;
181	break;
182
183	case '+':
184	fforward(integ ? integ : 1);
185	fpargs();
186	lastcom = PRCOM;
187	break;
188
189	case '\n':
190	switch (lastcom) {
191	case PRCOM:
192	fforward(1);
193	fprint();
194	break;
195	case DSCOM:
196	oaddr += oincr ? oincr : typetosize(otype, WORDSIZE);
197	printf("0x%x/ ", oaddr);
198	dispf((ADDR) oaddr, odesc,
199	oclass == N_RSYM ? oclass : N_GSYM, otype, 0, 0, DSP);
200	break;
201	case DSICOM:
202	dot += oincr;
203	prisploc();
204	dispi(dot, odesc, N_GSYM, 0, 0);
205	break;
206	}
207	break;
208
209	case '\004':
210	if (!isatty(0))
211	exit(0);
212	switch (lastcom) {
213	case PRCOM:
214	fforward(1);
215	printf("\b");
216	fprintn(WINDOW);
217	lastcom = PRCOM;
218	break;
219	case DSICOM:
220	printf("\b");
221	for (i=0; i<WINDOW; i++) {
222	dot += oincr;
223	prisploc();
224	if (dispi(dot, odesc, N_GSYM, 0, 0) == -1)
225	break;
226	}
227	break;
228	case DSCOM:
229	printf("\b");
230	for (i=0; i<WINDOW; i++) {
231	oaddr += oincr ?
232	oincr : typetosize(otype, WORDSIZE);
233	printf("0x%x/ ", oaddr);
234	if (dispf((ADDR) oaddr, odesc,
235	oclass == N_RSYM ? oclass :
236	N_GSYM, otype, 0, 0, DSP) == -1)
237	break;
238	}
239	break;
240	default:
241	printf("\n");
242	}
243	break;
244
245	case 'r':
246	if (args[0] == '\0') getargs();
247	case 'R':
248	signo = 0;
249	cpstr(oldargs, args);
250	if (debug) error("calling dopcs");
251	if (integ) cntval = integ;
252	if (!executing) {
253	executing = TRUE;
254	if (integ) cntval = integ;
255	dopcs('r');
256	executing = FALSE;
257	}
258	if (debug) error("exiting dopcs");
259	bkaddr = -1;
260	goto f1;
261
262	case 'c':
263	signo = 0;
264	case 'C':
265	if (proc[0] != '\0' \|\| integ != 0) {
266	setdot();
267	if (dot == -1) {
268	error("Cannot set temporary breakpoint");
269	break;
270	}
271	dopcs('b');
272	bkaddr = dot;
273	} else
274	bkaddr = -1;
275	integ = atoi(args);
276
277	f1: if (debug) error("calling dopcs");
278	if (integ) cntval = integ;
279	dopcs('c');
280	if (debug) error("exiting dopcs");
281	if (bkaddr != -1) {
282	ADDR dotsave;
283	dotsave = dot;
284	dot = bkaddr;
285	dopcs('d');
286	dot = dotsave;
287	}
288	if (!signo) printf("Breakpoint");
289	printf(" at\n");
290	setcur(1);
291	lastcom = NOCOM;
292	break;
293
294	case 'S':
295	case 's':
296	signo = 0;
297	integ = atoi(args);
298	singstep(integ ? integ : 1, cmd);
299	if (signo) printf("\n");
300	setcur(1);
301	lastcom = NOCOM;
302	break;
303
304	case 'g':
305	if (pid == 0 \|\| signo) {
306	error("Not stopped at breakpoint");
307	break;
308	}
309	setdot();
310	if (dot == -1) {
311	error("Bad address");
312	break;
313	}
314	adrflg = 1;
315	integ = atoi(args);
316	if (integ) cntval = integ;
317	dopcs('c');
318	if (!signo) printf("Breakpoint");
319	printf(" at\n");
320	setcur(1);
321	lastcom = NOCOM;
322	break;
323
324	case 'k':
325	if (scallx) {
326	userpc = dot = (ADDR )(((ADDR)&u)+PC) = pcs;
327	(ADDR )(((ADDR)&u)+FP) = fps;
328	(ADDR )(((ADDR)&u)+AP) = aps;
329	if (bkpts)
330	bkpts->flag = flagss;
331	scallx = 0;
332	error("Procedure killed");
333	longjmp(env, 0);
334	} else {
335	dopcs('k');
336	printf("\n");
337	lastcom = NOCOM;
338	break;
339	}
340
341	case 'B':
342	prbkpt();
343	break;
344
345	case 'b':
346	setbrk:
347	if (proc[0] == '\0' && integ == 0) {
348	integ = fline;
349	}
350	setdot();
351	if (dot == -1 \|\| dot == 0) {
352	error("Cannot set breakpoint");
353	break;
354	}
355	dopcs('b');
356	s[0] = ' ';
357	s[1] = cmd;
358	s[2] = '\n';
359	s[3] = 0;
360	s[1] = cmd;
361	printbkpt(s, adrtoprocp(dot), dot);
362	break;
363
364	case 'd':
365	if (proc[0] == '\0' && integ == 0) {
366	idbkpt();
367	break;
368	}
369	setdot();
370	if (dot == -1) {
371	error("Non existent breakpoint");
372	break;
373	}
374	dopcs('d');
375	break;
376
377	case 'D':
378	dabkpt();
379	error("All breakpoints deleted");
380	break;
381
382	case 'm':
383	addr = varaddr(proc[0] ? proc : curproc()->pname, var);
384	printf("stopped with value %d\n", monex(addr, 'd'));
385	setcur(1);
386	lastcom = NOCOM;
387	break;
388
389	case '?':
390	if (!(var[0] == '.' && var[1] == '\0'))
391	setdot();
392	if (errflg) {
393	error(errflg);
394	break;
395	}
396	prisploc();
397	dispi(dot, args[0] ? args : "i", N_GSYM, 0, 0);
398	lastcom = DSICOM;
399	break;
400
401	case '/':
402	if (var[0] == '.' && var[1] == '\0') {
403	if (integ == 0) integ = oaddr;
404	dispf((ADDR) integ, args[0] ? args : odesc,
405	oclass == N_RSYM ? oclass : N_GSYM, otype, 0, 0, DSP);
406	oaddr = integ;
407	} else
408	if (integ && (var[0] == '\0')) {
409	dispf((ADDR) integ, args, N_GSYM, 0, 0, 0, DSP);
410	oaddr = integ;
411	cpstr(odesc, args);
412	oclass = N_GSYM;
413	otype = 0;
414	} else
415	dispvar(proc, var, args);
416	lastcom = DSCOM;
417	break;
418
419	case '=':
420	if (var[0] == '\0') {
421	if (proc[0]) {
422	addr = getaddr(proc, integ);
423	if (addr == -1) {
424	error("Unknown address");
425	break;
426	}
427	}
428	else
429	addr = integ;
430	dispf(addr, args[0] ? args : "x", 0, -1, 0, 0, DSP);
431	} else
432	findvar(proc, var, args[0] ? args : "x", 2);
433	break;
434
435	case '!':
436	if (var[0] == '\0')
437	addr = getaddr(proc, integ);
438	else
439	addr = varaddr(proc, var);
440	if (addr == -1)
441	error("Unknown variable");
442	else {
443	if (number(args[0]) \|\| eqany(args[0], ".-")) {
444	char *p;
445	double atof();
446	union {
447	struct{
448	int w1, w2;
449	} ww;
450	double d;
451	} dbl;
452
453	p = (args[0] == '-') ? args+1 : args;
454	for (; p != '.' && p != 'e'; p++) {
455	if (!number(*p)) goto l2;
456	}
457	dbl.d = atof(args);
458	putval(addr, 'd', dbl.ww.w1);
459	if (typetodesc(sl_type,0)[0] == 'g')
460	putval(addr+WORDSIZE, 'd', dbl.ww.w2);
461	break;
462	}
463	l2: if (percentflag)
464	(ADDR )(((ADDR)&u)+addr) = argvalue(args);
465	else if (sl_class == N_RSYM && addr < 16)
466	putreg(addr,typetodesc(sl_type,subflag)[0],
467	argvalue(args));
468	else
469	putval(addr,typetodesc(sl_type,subflag)[0],
470	argvalue(args));
471	}
472	lastcom = NOCOM;
473	break;
474
475	case '"':
476	printf(args);
477	break;
478	}
479	}
480
481	fpargs() {
482	register int i;
483
484	switch(args[0]) {
485	case 'p':
486	case '\0':
487	fprint();
488	break;
489	case 'w':
490	i = fline;
491	fback(WINDOW/2);
492	fprintn(WINDOW);
493	ffind(i);
494	break;
495	case 'z':
496	fprintn(WINDOW);
497	break;
498	}
499	}
500
501	MSG BADTXT;
502	/* Used by a, b, c, C, d and g commands to find linenumber */
503	setdot() {
504	if (ncolonflag) {
505	dot = integ;
506	get(dot, ISP);
507	if (errflg)
508	dot = -1;
509	} else {
510	dot = getaddr(proc, integ);
511	if (dot == -1)
512	errflg = "Bad line number";
513	}
514	}