![[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 [Research Unix] / researchv10no / cmd / sdb|
Return to sub.c CVS log | Up to [Research Unix] / researchv10no / 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: clearerr(f);
23: }
24: else *p = i;
25: } while (*p++ != '\n');
26:
27: return(buff);
28: }
29:
30: char *
31: cpname(p, q)
32: char *p, *q; {
33: while(varchar(*q) || number(*q))
34: *p++ = *q++;
35: *p = '\0';
36: return(q);
37: }
38:
39: char *
40: cpall(p, q)
41: char *p, *q; {
42: while (*q != '\n')
43: *p++ = *q++;
44: *p = '\0';
45: return(q);
46: }
47:
48: eqany(c, s)
49: char c, *s; {
50: while(*s != '\0')
51: if (c == *s++) return(1);
52: return(0);
53: }
54:
55: error(s)
56: char *s; {
57: printf("%s\n", s);
58: }
59:
60: char *
61: cpstr(p,q)
62: char *p, *q; {
63: do {
64: *p++ = *q++;
65: } while (*q != '\0');
66: *p = '\0';
67: }
68: L_INT
69: round(a,b)
70: REG L_INT a, b;
71: {
72: REG L_INT w;
73: w = (a/b)*b;
74: IF a!=w THEN w += b; FI
75: return(w);
76: }
77:
78: /* error handling */
79:
80: chkerr()
81: {
82: IF errflg ORF mkfault
83: THEN error(errflg);
84: longjmp(env, 0);
85: FI
86: }
87:
88: eqstr(s1, s2)
89: REG STRING s1, s2;
90: {
91: #ifndef FLEXNAMES
92: REG STRING es1;
93: #endif
94: if (s2 == (STRING) -1) return(0);
95: #ifndef FLEXNAMES
96: es1 = s1+8;
97: #endif
98: WHILE *s1++ == *s2
99: #ifndef FLEXNAMES
100: DO IF *s2++ == 0 ORF s1>=es1
101: #else
102: DO IF *s2++ == 0
103: #endif
104: THEN return(1);
105: FI
106: OD
107: return(0);
108: }
109:
110: longseek(f, a)
111: L_INT a;
112: {
113: return(lseek(f,(long) a,0) != -1);
114: }
115:
116:
117: /* descriptor format to length */
118: dtol(d)
119: char d; {
120: switch(d) {
121:
122: case 'a':
123: case 's':
124: return(0);
125:
126: case 'b':
127: case 'c':
128: return(1);
129:
130: case 'h':
131: return(2);
132:
133: case 'l':
134: case 'f':
135: return(4);
136:
137: case 'g':
138: return(8);
139:
140: default:
141: return(WORDSIZE);
142: }
143: }
144:
145: /*
146: * checks equality of pattern pat with str,
147: * assuming str is tructaed at length 8
148: */
149: eqpat(pat, str)
150: char *pat, *str; {
151: #ifndef FLEXNAMES
152: return(eqpatr(pat, str, 0));
153: #else
154: return(eqpatr(pat, str));
155: #endif
156: }
157:
158: #ifndef FLEXNAMES
159: eqpatr(pat, str, cnt)
160: #else
161: eqpatr(pat, str)
162: #endif
163: char *pat, *str; {
164: register int i;
165: register char p, s;
166:
167: p = pat[0];
168: s = str[0];
169: #ifndef FLEXNAMES
170: if (cnt == 8) return(1);
171: #endif
172: if (p == '?') {
173: if (s == '\0') return(0);
174: #ifndef FLEXNAMES
175: return(eqpatr(pat+1, str+1, cnt+1));
176: #else
177: return(eqpatr(pat+1, str+1));
178: #endif
179: }
180: if (p == '*') {
181: if (pat[1] == '\0') return(1);
182: #ifndef FLEXNAMES
183: for(i=1; i<8-cnt; i++) {
184: if (eqpatr(pat+1, str+i, cnt+i)) return(1);
185: #else
186: for(i=1; ; i++) {
187: if (eqpatr(pat+1, str+i)) return(1);
188: #endif
189: if (str[i] == '\0') return(0);
190: }
191: #ifndef FLEXNAMES
192: return(0);
193: #else
194: /*NOTREACHED*/
195: #endif
196: }
197: if ((eqany(p, ".[->") || p == '\0') && s == '\0') return(1);
198: if (p != s) return(0);
199: #ifndef FLEXNAMES
200: return(eqpatr(pat+1, str+1, cnt+1));
201: #else
202: return(eqpatr(pat+1, str+1));
203: #endif
204: }
205:
206: /* gets indirect address for pointers and subscripts */
207: getindir(class, addr, type)
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 = base*value + (*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: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.