![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sub.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 40BSD / cmd / sdb|
Return to sub.c CVS log | Up to [CSRG BSD Unix] / 40BSD / cmd / sdb |
1.1 root 1: static char sccsid[] = "@(#)sub.c 4.1 10/9/80";
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)
207: ADDR addr; {
208: if (ISARY(type)) return(addr);
209: if (class == N_RSYM)
210: return(*(ADDR *)(((ADDR) &u) + R0 + (WORDSIZE)*addr));
211: return(getval(addr, 'd', DSP));
212: }
213:
214: long
215: readint(p)
216: char **p; {
217: int sign;
218:
219: if (**p == '-') {
220: sign = -1;
221: (*p)++;
222: } else {
223: sign = 1;
224: }
225: if (**p == '0') {
226: (*p)++;
227: if (**p == 'x' || **p == 'X') {
228: (*p)++;
229: return(sign * rint(p, 16, hexdigit, hexconv));
230: }
231: else return(sign * rint(p, 8, octdigit, octconv));
232: }
233: else return(sign * rint(p, 10, decdigit, decconv));
234: }
235:
236: long
237: rint(p, base, digit, conv)
238: char **p;
239: int (*digit)(), (*conv)(); {
240: long value;
241:
242: value = 0;
243: while ((*digit)(**p)) value = base*value + (*conv)(*(*p)++);
244: return(value);
245: }
246:
247: octdigit(c)
248: char c; {
249: return(c >= '0' && c <= '7');
250: }
251:
252: octconv(c)
253: char c; {
254: return(c - '0');
255: }
256:
257: decdigit(c)
258: char c; {
259: return(c >= '0' && c <= '9');
260: }
261:
262: decconv(c)
263: char c; {
264: return(c - '0');
265: }
266:
267: hexdigit(c)
268: char c; {
269: return((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') ||
270: (c >= 'A' && c <= 'F'));
271: }
272:
273: hexconv(c)
274: char c; {
275: if (c >= '0' && c <= '9') return(c - '0');
276: if (c >= 'a' && c <= 'f') return(c - 'a' + 10);
277: if (c >= 'A' && c <= 'F') return(c - 'A' + 10);
278: error("hex conversion error");
279: return(0);
280: }
281:
282: /* decodes number, character or variable */
283: long
284: argvalue(p)
285: char *p; {
286: register char ch;
287: register long value;
288: register ADDR j;
289: char var[30];
290:
291: ch = *p;
292: if (ch == '\'') {
293: value = *(p+1);
294: } else if ((ch >= '0' && ch <= '9') || ch == '-') {
295: value = readint(&p);
296: } else if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
297: ch == '_') {
298: cpname(var, p);
299: j = varaddr(curproc()->pname, var);
300: if (j == -1) {
301: printf("Unknown variable: %s\n", argsp);
302: return(-1);
303: }
304: value = getval(j, typetodesc(sl_type, 0)[0], DSP);
305: do {
306: p++;
307: } while (varchar(*p) || number(*p));
308: }
309: return(value);
310: }
311:
312: prhex(v)
313: long v; {
314: if (v < 0) {
315: v = -v;
316: printf("-");
317: }
318: if (v <= 9)
319: printf("%d", v);
320: else
321: printf("0x%x", v);
322: }
323:
324: /* print hex number in field of length 12 */
325: prhex12(v)
326: long v; {
327: if (v >= -9 && v <= 9)
328: printf("%-12d", v);
329: else
330: printf("0x%-12x", v);
331: }
332:
333: /* print line number followed by offset */
334: prlnoff(procp, v)
335: struct proct *procp; ADDR v; {
336: int lineno, diff;
337: char *name;
338: name = procp->pname;
339: if (name[0] == '_') {
340: #ifndef FLEXNAMES
341: printf("%.7s", name+1);
342: #else
343: printf("%s", name+1);
344: #endif
345: lineno = -1;
346: } else {
347: #ifndef FLEXNAMES
348: printf("%8s", name);
349: #else
350: printf("%s", name);
351: #endif
352: lineno = adrtolineno((ADDR) v);
353: }
354: if (lineno == -1)
355: diff = v - procp->paddr;
356: else {
357: printf(":%d", lineno);
358: diff = v - lnfaddr; /* set by adrtolineno() */
359: }
360: if (diff) {
361: printf("+");
362: prhex(diff);
363: }
364: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.