[unix-history] / usr / src / old / sdb / sub.c

static	char sccsid[] = "@(#)sub.c 4.2 %G%";
#include "head.h"
#include <a.out.h>
#include <stab.h>
#include "cdefs.h"
#include <stdio.h>
struct user u;

char *
readline(f)
FILE *f; {
	static char buff[128];
	
	register char *p;
	register int i;
	
	p = buff;
	do {
		if ((i = getc(f)) == EOF) {
			*p++ = '\004';
			*p = '\n';
		}
		else *p = i;
	} while (*p++ != '\n');
	
	return(buff);
}

char *
cpname(p, q)
char *p, *q; {
	while(varchar(*q) || number(*q))
		*p++ = *q++;
	*p = '\0';
	return(q);
}

char *
cpall(p, q)
char *p, *q; {
	while (*q != '\n') 
		*p++ = *q++;
	*p = '\0';
	return(q);
}

eqany(c, s)
char c, *s; {
	while(*s != '\0')
		if (c == *s++) return(1);
	return(0);
}

error(s)
char *s; {
	printf("%s\n", s);
}

char *
cpstr(p,q)
char *p, *q; {
	do {
		*p++ = *q++;
	} while (*q != '\0');
	*p = '\0';
}
L_INT
round(a,b)
REG L_INT a, b;
{
	REG L_INT w;
	w = (a/b)*b;
	IF a!=w THEN w += b; FI
	return(w);
}

/* error handling */

chkerr()
{
	IF errflg ORF mkfault
	THEN	error(errflg);
		longjmp(env, 0);
	FI
}

eqstr(s1, s2)
	REG STRING	s1, s2;
{
#ifndef FLEXNAMES
	REG STRING	 es1;
#endif
	if (s2 == (STRING) -1) return(0);
#ifndef FLEXNAMES
	es1 = s1+8;
#endif
	WHILE *s1++ == *s2
#ifndef FLEXNAMES
	DO IF *s2++ == 0 ORF s1>=es1
#else
	DO IF *s2++ == 0
#endif
	   THEN return(1);
	   FI
	OD
	return(0);
}

longseek(f, a)
L_INT a;
{
	return(lseek(f,(long) a,0) != -1);
}


/* descriptor format to length */
dtol(d)
char d; {
	switch(d) {
	
	case 'a':
	case 's':
		return(0);
		
	case 'b':
	case 'c':
		return(1);
		
	case 'h':
		return(2);
		
	case 'l':
	case 'f':
		return(4);

	case 'g':
		return(8);

	default:
		return(WORDSIZE);
	}
}

/*
 * checks equality of pattern pat with str,
 * assuming str is tructaed at length 8
 */
eqpat(pat, str)
char *pat, *str; {
#ifndef FLEXNAMES
	return(eqpatr(pat, str, 0));
#else
	return(eqpatr(pat, str));
#endif
}

#ifndef FLEXNAMES
eqpatr(pat, str, cnt)
#else
eqpatr(pat, str)
#endif
char *pat, *str; {
	register int i;
	register char p, s;
	
	p = pat[0];
	s = str[0];
#ifndef FLEXNAMES
	if (cnt == 8) return(1);
#endif
	if (p == '?') {
		if (s == '\0') return(0);
#ifndef FLEXNAMES
		return(eqpatr(pat+1, str+1, cnt+1));
#else
		return(eqpatr(pat+1, str+1));
#endif
	}
	if (p == '*') {
		if (pat[1] == '\0') return(1);
#ifndef FLEXNAMES
		for(i=1; i<8-cnt; i++) {
			if (eqpatr(pat+1, str+i, cnt+i)) return(1);
#else
		for(i=1; ; i++) {
			if (eqpatr(pat+1, str+i)) return(1);
#endif
			if (str[i] == '\0') return(0);
		}
#ifndef FLEXNAMES
		return(0);
#else
		/*NOTREACHED*/
#endif
	}
	if ((eqany(p, ".[->") || p == '\0') && s == '\0') return(1);
	if (p != s) return(0);
#ifndef FLEXNAMES
	return(eqpatr(pat+1, str+1, cnt+1));
#else
	return(eqpatr(pat+1, str+1));
#endif
}

/* gets indirect address for pointers and subscripts */
getindir(class, addr, type) 
u_char class;
ADDR addr; {
	if (ISARY(type)) return(addr);
	if (class == N_RSYM)
		return(*(ADDR *)(((ADDR) &u) + R0 + (WORDSIZE)*addr));
	return(getval(addr, 'd', DSP));
}

long
readint(p)
char **p; {
	int sign;

	if (**p == '-') {
		sign = -1;
		(*p)++;
	} else {
		sign = 1;
	}
	if (**p == '0') {
		(*p)++;
		if (**p == 'x' || **p == 'X') {
			(*p)++;
			return(sign * rint(p, 16, hexdigit, hexconv));
		}
		else return(sign * rint(p, 8, octdigit, octconv));
	}
	else return(sign * rint(p, 10, decdigit, decconv));
}

long
rint(p, base, digit, conv)
char **p;
int (*digit)(), (*conv)(); {
	long value;
	
	value = 0;
	while ((*digit)(**p)) value = base*value + (*conv)(*(*p)++);  
	return(value);
}

octdigit(c) 
char c; {
	return(c >= '0' && c <= '7');
}

octconv(c)
char c; {
	return(c - '0');
}

decdigit(c)
char c; {
	return(c >= '0' && c <= '9');
}

decconv(c)
char c; {
	return(c - '0');
}

hexdigit(c)
char c; {
	return((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') ||
		(c >= 'A' && c <= 'F'));
}

hexconv(c)
char c; {
	if (c >= '0' && c <= '9') return(c - '0');
	if (c >= 'a' && c <= 'f') return(c - 'a' + 10);
	if (c >= 'A' && c <= 'F') return(c - 'A' + 10);
	error("hex conversion error");
	return(0);
}

/* decodes number, character or variable */
long
argvalue(p)
char *p; {
	register char ch;
	register long value;
	register ADDR j;
	char var[30];

	ch = *p;
	if (ch == '\'') {
		value = *(p+1);
	} else if ((ch >= '0' && ch <= '9') || ch == '-') {
		value = readint(&p);
	} else if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
		ch == '_') {
		cpname(var, p);
		j = varaddr(curproc()->pname, var);
		if (j == -1) {
			printf("Unknown variable: %s\n", argsp);
			return(-1);
		}
		value = getval(j, typetodesc(sl_type, 0)[0], DSP);
		do {
			p++;
		} while (varchar(*p) || number(*p));
	}
	return(value);
}

prhex(v) 
long v; {
	if (v < 0)  {
		v = -v;
		printf("-");
	}
	if (v <= 9)
		printf("%d", v);
	else
		printf("0x%x", v);
}

/* print hex number in field of length 12 */
prhex12(v) 
long v; {
	if (v >= -9 && v <= 9)
		printf("%-12d", v);
	else
		printf("0x%-12x", v);
}

/* print line number followed by offset */
prlnoff(procp, v)
struct proct *procp; ADDR v; {
	int lineno, diff;
	char *name;
	name = procp->pname;
	if (name[0] == '_') {
#ifndef FLEXNAMES
		printf("%.7s", name+1);
#else
		printf("%s", name+1);
#endif
		lineno = -1;
	} else {
#ifndef FLEXNAMES
		printf("%8s", name);
#else
		printf("%s", name);
#endif
		lineno = adrtolineno((ADDR) v);
	}
	if (lineno == -1)
		diff = v - procp->paddr;
	else {
		printf(":%d", lineno);
		diff = v - lnfaddr;  /* set by adrtolineno() */
	}
	if (diff) {
		printf("+");
		prhex(diff);
	}
}
Commit	Line	Data
28c97a66	1	static char sccsid[] = "@(#)sub.c 4.2 %G%";
1c71ee4a BJ	2	#include "head.h"
	3	#include <a.out.h>
	4	#include <stab.h>
	5	#include "cdefs.h"
	6	#include <stdio.h>
	7	struct user u;
	8
	9	char *
	10	readline(f)
	11	FILE *f; {
	12	static char buff[128];
	13
	14	register char *p;
	15	register int i;
	16
	17	p = buff;
	18	do {
	19	if ((i = getc(f)) == EOF) {
	20	*p++ = '\004';
	21	*p = '\n';
	22	}
	23	else *p = i;
	24	} while (*p++ != '\n');
	25
	26	return(buff);
	27	}
	28
	29	char *
	30	cpname(p, q)
	31	char p, q; {
	32	while(varchar(q) \|\| number(q))
	33	p++ = q++;
	34	*p = '\0';
	35	return(q);
	36	}
	37
	38	char *
	39	cpall(p, q)
	40	char p, q; {
	41	while (*q != '\n')
	42	p++ = q++;
	43	*p = '\0';
	44	return(q);
	45	}
	46
	47	eqany(c, s)
	48	char c, *s; {
	49	while(*s != '\0')
	50	if (c == *s++) return(1);
	51	return(0);
	52	}
	53
	54	error(s)
	55	char *s; {
	56	printf("%s\n", s);
	57	}
	58
	59	char *
	60	cpstr(p,q)
	61	char p, q; {
	62	do {
	63	p++ = q++;
	64	} while (*q != '\0');
	65	*p = '\0';
66	}
67	L_INT
68	round(a,b)
69	REG L_INT a, b;
70	{
71	REG L_INT w;
72	w = (a/b)*b;
73	IF a!=w THEN w += b; FI
74	return(w);
75	}
76
77	/* error handling */
78
79	chkerr()
80	{
81	IF errflg ORF mkfault
82	THEN error(errflg);
83	longjmp(env, 0);
84	FI
85	}
86
87	eqstr(s1, s2)
88	REG STRING s1, s2;
89	{
90	#ifndef FLEXNAMES
91	REG STRING es1;
92	#endif
93	if (s2 == (STRING) -1) return(0);
94	#ifndef FLEXNAMES
95	es1 = s1+8;
96	#endif
97	WHILE s1++ == s2
98	#ifndef FLEXNAMES
99	DO IF *s2++ == 0 ORF s1>=es1
100	#else
101	DO IF *s2++ == 0
102	#endif
103	THEN return(1);
104	FI
105	OD
106	return(0);
107	}
108
109	longseek(f, a)
110	L_INT a;
111	{
112	return(lseek(f,(long) a,0) != -1);
113	}
114
115
116	/* descriptor format to length */
117	dtol(d)
118	char d; {
119	switch(d) {
120
121	case 'a':
122	case 's':
123	return(0);
124
125	case 'b':
126	case 'c':
127	return(1);
128
129	case 'h':
130	return(2);
131
132	case 'l':
133	case 'f':
134	return(4);
135
136	case 'g':
137	return(8);
138
139	default:
140	return(WORDSIZE);
141	}
142	}
143
144	/*
145	* checks equality of pattern pat with str,
146	* assuming str is tructaed at length 8
147	*/
148	eqpat(pat, str)
149	char pat, str; {
150	#ifndef FLEXNAMES
151	return(eqpatr(pat, str, 0));
152	#else
153	return(eqpatr(pat, str));
154	#endif
155	}
156
157	#ifndef FLEXNAMES
158	eqpatr(pat, str, cnt)
159	#else
160	eqpatr(pat, str)
161	#endif
162	char pat, str; {
163	register int i;
164	register char p, s;
165
166	p = pat[0];
167	s = str[0];
168	#ifndef FLEXNAMES
169	if (cnt == 8) return(1);
170	#endif
171	if (p == '?') {
172	if (s == '\0') return(0);
173	#ifndef FLEXNAMES
174	return(eqpatr(pat+1, str+1, cnt+1));
175	#else
176	return(eqpatr(pat+1, str+1));
177	#endif
178	}
179	if (p == '*') {
180	if (pat[1] == '\0') return(1);
181	#ifndef FLEXNAMES
182	for(i=1; i<8-cnt; i++) {
183	if (eqpatr(pat+1, str+i, cnt+i)) return(1);
184	#else
185	for(i=1; ; i++) {
186	if (eqpatr(pat+1, str+i)) return(1);
187	#endif
188	if (str[i] == '\0') return(0);
189	}
190	#ifndef FLEXNAMES
191	return(0);
192	#else
193	/NOTREACHED/
194	#endif
195	}
196	if ((eqany(p, ".[->") \|\| p == '\0') && s == '\0') return(1);
197	if (p != s) return(0);
198	#ifndef FLEXNAMES
199	return(eqpatr(pat+1, str+1, cnt+1));
200	#else
201	return(eqpatr(pat+1, str+1));
202	#endif
203	}
204
205	/* gets indirect address for pointers and subscripts */
206	getindir(class, addr, type)
28c97a66	207	u_char class;
1c71ee4a BJ	208	ADDR addr; {
	209	if (ISARY(type)) return(addr);
	210	if (class == N_RSYM)
	211	return((ADDR )(((ADDR) &u) + R0 + (WORDSIZE)*addr));
	212	return(getval(addr, 'd', DSP));
	213	}
	214
	215	long
	216	readint(p)
	217	char **p; {
	218	int sign;
	219
	220	if (**p == '-') {
	221	sign = -1;
	222	(*p)++;
	223	} else {
	224	sign = 1;
	225	}
	226	if (**p == '0') {
	227	(*p)++;
	228	if (p == 'x' \|\| p == 'X') {
	229	(*p)++;
	230	return(sign * rint(p, 16, hexdigit, hexconv));
	231	}
	232	else return(sign * rint(p, 8, octdigit, octconv));
	233	}
	234	else return(sign * rint(p, 10, decdigit, decconv));
	235	}
	236
	237	long
	238	rint(p, base, digit, conv)
	239	char **p;
	240	int (digit)(), (conv)(); {
	241	long value;
	242
	243	value = 0;
	244	while ((digit)(p)) value = basevalue + (conv)((*p)++);
	245	return(value);
	246	}
	247
	248	octdigit(c)
	249	char c; {
	250	return(c >= '0' && c <= '7');
	251	}
	252
	253	octconv(c)
	254	char c; {
	255	return(c - '0');
	256	}
	257
	258	decdigit(c)
	259	char c; {
	260	return(c >= '0' && c <= '9');
	261	}
	262
	263	decconv(c)
	264	char c; {
	265	return(c - '0');
	266	}
	267
	268	hexdigit(c)
	269	char c; {
	270	return((c >= '0' && c <= '9') \|\| (c >= 'a' && c <= 'f') \|\|
	271	(c >= 'A' && c <= 'F'));
272	}
273
274	hexconv(c)
275	char c; {
276	if (c >= '0' && c <= '9') return(c - '0');
277	if (c >= 'a' && c <= 'f') return(c - 'a' + 10);
278	if (c >= 'A' && c <= 'F') return(c - 'A' + 10);
279	error("hex conversion error");
280	return(0);
281	}
282
283	/* decodes number, character or variable */
284	long
285	argvalue(p)
286	char *p; {
287	register char ch;
288	register long value;
289	register ADDR j;
290	char var[30];
291
292	ch = *p;
293	if (ch == '\'') {
294	value = *(p+1);
295	} else if ((ch >= '0' && ch <= '9') \|\| ch == '-') {
296	value = readint(&p);
297	} else if ((ch >= 'a' && ch <= 'z') \|\| (ch >= 'A' && ch <= 'Z') \|\|
298	ch == '_') {
299	cpname(var, p);
300	j = varaddr(curproc()->pname, var);
301	if (j == -1) {
302	printf("Unknown variable: %s\n", argsp);
303	return(-1);
304	}
305	value = getval(j, typetodesc(sl_type, 0)[0], DSP);
306	do {
307	p++;
308	} while (varchar(p) \|\| number(p));
309	}
310	return(value);
311	}
312
313	prhex(v)
314	long v; {
315	if (v < 0) {
316	v = -v;
317	printf("-");
318	}
319	if (v <= 9)
320	printf("%d", v);
321	else
322	printf("0x%x", v);
323	}
324
325	/* print hex number in field of length 12 */
326	prhex12(v)
327	long v; {
328	if (v >= -9 && v <= 9)
329	printf("%-12d", v);
330	else
331	printf("0x%-12x", v);
332	}
333
334	/* print line number followed by offset */
335	prlnoff(procp, v)
336	struct proct *procp; ADDR v; {
337	int lineno, diff;
338	char *name;
339	name = procp->pname;
340	if (name[0] == '_') {
341	#ifndef FLEXNAMES
342	printf("%.7s", name+1);
343	#else
344	printf("%s", name+1);
345	#endif
346	lineno = -1;
347	} else {
348	#ifndef FLEXNAMES
349	printf("%8s", name);
350	#else
351	printf("%s", name);
352	#endif
353	lineno = adrtolineno((ADDR) v);
354	}
355	if (lineno == -1)
356	diff = v - procp->paddr;
357	else {
358	printf(":%d", lineno);
359	diff = v - lnfaddr; /* set by adrtolineno() */
360	}
361	if (diff) {
362	printf("+");
363	prhex(diff);
364	}
365	}