![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to prvar.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / old / sdb|
Return to prvar.c CVS log | Up to [CSRG BSD Unix] / 43BSD / old / sdb |
1.1 root 1: static char sccsid[] = "@(#)prvar.c 4.3 8/17/82";
2: #include "head.h"
3: #include <a.out.h>
4: #include <stab.h>
5: #include "cdefs.h"
6: struct user u;
7: BKPTR bkpthead;
8: STRING errflg;
9:
10: /*
11: * outvar():
12: * Prints named variable, recursing once for each structure member or
13: * subscript.
14: * proc:var: variable name
15: * fmt: print format
16: * metaflag: set iff var contains metacharacters * or ?
17: * addr: partial address of variable, initally 0
18: * class: type class of variable
19: * subflag: number of levels of subscript indirection
20: * prnamep: pointer to end of partially formed print name of variable
21: * comblk: name of common block containing variable, if any
22: * prvar: as in findvar
23: *
24: * Here and elsewhere we assume that -1 is an invalid address, and
25: * its is used to indicate error.
26: */
27: outvar(proc, var, fmt, metaflag, addr, class, subflag, prnamep,
28: comblk, prvar)
29: ADDR addr; char *proc, *var, *fmt, *prnamep, *comblk; u_char class; {
30: char *p, *q, *r, *oldpr;
31: register int match;
32: long soffset, goffset;
33: register ADDR newaddr = -1, arrowaddr;
34: register enum {INIT, ARROW, DOT} typeflag;
35:
36: switch (var[0]) {
37: case '\0':
38: if (prvar == 0) return(addr);
39: if (metaflag) {
40: if (comblk[0] && !(eqstr(comblk, "*")))
41: #ifndef FLEXNAMES
42: printf("%.8s:%.8s", comblk, prname);
43: #else
44: printf("%s:%s", comblk, prname);
45: #endif
46: else if (proc[0])
47: #ifndef FLEXNAMES
48: printf("%.8s:%.8s", proc, prname);
49: #else
50: printf("%s:%s", proc, prname);
51: #endif
52: else
53: printf("%s", prname);
54: }
55: printit(metaflag, prvar, addr, fmt, class, sl_type,
56: sl_size, subflag, DSP);
57: return(addr);
58:
59: case '[':
60: *prnamep++ = *var++;
61: p = var;
62: for (;;) {
63: *prnamep++ = *var;
64: if (*var == '\0' || *var == ']') break;
65: var++;
66: }
67: newaddr = getindir(class, addr, sl_type);
68: newaddr += typetosize(sl_type, sl_size) * readint(&p);
69: return(outvar(proc, var+1, fmt, metaflag, newaddr, N_GSYM,
70: subflag+1, prnamep, comblk, prvar));
71:
72: case '-':
73: case '>':
74: typeflag = ARROW;
75: while (eqany(*var, "->"))
76: *prnamep++ = *var++;
77: subflag++;
78: arrowaddr = getindir(class, addr, sl_type);
79: if (errflg) {
80: printf("%s\n", errflg);
81: errflg = 0;
82: return(0);
83: }
84: class = N_GSYM;
85: if (var[0] == '\0') {
86: p = var;
87: newaddr = arrowaddr;
88: goto recurse;
89: }
90: break;
91:
92: case '.':
93: typeflag = DOT;
94: if (class == N_RSYM) {
95: error("Not with a register variable");
96: return(0);
97: }
98: *prnamep++ = *var++;
99: subflag = 0;
100: break;
101:
102: default:
103: typeflag = INIT;
104: break;
105: }
106:
107: if (typeflag == INIT) {
108: soffset = proc[0] ? adrtostoffset(callpc-1) : -1;
109: goffset = proc[0] ? -1 : findfile(curfile)->stf_offset;
110: } else {
111: soffset = proc[0] ? adrtostoffset(callpc-1) : -1;
112: goffset = findfile(curfile)->stf_offset;
113: }
114:
115: p = var;
116: oldpr = prnamep;
117: while (!eqany(*p, "->.[") && *p != '\0')
118: *prnamep++ = *p++;
119: *prnamep = '\0';
120:
121: match = 0;
122: slookinit();
123:
124: for (;;) {
125: if (soffset != -1)
126: if ((soffset = slooknext(var, soffset, typeflag!=INIT,
127: comblk)) != -1)
128: goto found;
129: if (goffset != -1)
130: if ((goffset = globallookup(var, goffset,
131: typeflag!=INIT)) != -1)
132: goto found;
133: return(newaddr);
134:
135: found:
136: r = sl_name;
137: q = oldpr;
138: while (*r) *q++ = *r++;
139: *q ='\0';
140:
141: switch(typeflag) {
142: case INIT:
143: class = sl_class & STABMASK;
144: if (!varclass(class) || class == N_SSYM)
145: goto l;
146: newaddr = (class == N_LSYM) ? -sl_addr : sl_addr;
147: newaddr = formaddr(class, newaddr);
148: break;
149:
150: case ARROW:
151: class = sl_class & STABMASK;
152: if (!varclass(class) || class != N_SSYM)
153: goto l;
154: newaddr = arrowaddr + sl_addr;
155: break;
156:
157: case DOT:
158: class = sl_class & STABMASK;
159: if (!varclass(class) || class != N_SSYM)
160: goto l;
161: newaddr = addr + sl_addr;
162: break;
163: }
164:
165: recurse:
166: newaddr = outvar(proc, p, fmt, metaflag, newaddr,
167: class, subflag, prnamep, comblk, prvar);
168:
169: if (!metaflag)
170: return(newaddr);
171: l:; }
172: }
173:
174: /* Output external variables. Arguments as in outvar() */
175: extoutvar(var, fmt, metaflag, prvar)
176: char *var, *fmt; {
177: long offset;
178: ADDR addr = -1;
179:
180: offset = extstart;
181: sl_addr = -1;
182:
183: for (;;) {
184: offset = extlookup(var, offset);
185: addr = sl_addr;
186: if (offset == -1)
187: return(addr);
188: if (metaflag)
189: #ifndef FLEXNAMES
190: printf("%.7s", sl_name);
191: #else
192: printf("%s", sl_name);
193: #endif
194: printit(metaflag, prvar, addr, fmt[0] ? fmt : "d",
195: N_GSYM, 0, 0, 0, DSP);
196: if (!metaflag)
197: return(addr);
198: }
199: }
200:
201: prdebug() {
202: register struct proct *procp;
203: register struct filet *filep;
204:
205: printf("dot=%d\n", dot);
206: printf("extstart = %d\n", extstart);
207: printf("firstdata = %d\n", firstdata);
208: for(filep=files;filep->sfilename[0];filep++)
209: printf("%s offs %d @ %d flag %d addr 0x%x\n", filep->sfilename, filep->stf_offset, filep, filep->lineflag, filep->faddr);
210: for(procp=procs;procp->pname[0];procp++) {
211: #ifndef FLEXNAMES
212: printf("%s addr 0x%x; offs %d; sfptr %d; line %d",
213: #else
214: printf("%8.8s addr 0x%x; offs %d; sfptr %d; line %d",
215: #endif
216: procp->pname, procp->paddr, procp->st_offset,
217: procp->sfptr, procp->lineno);
218: if (procp->entrypt) printf(" entrypoint");
219: printf("\n");
220: }
221: }
222:
223: /*
224: * display addr in data space using format desc or class s
225: * type == 1 => use addr for value to print
226: */
227: dispf(addr, desc, class, type, size, subflag, space)
228: u_char class;
229: char *desc; short type; ADDR addr; {
230: dispx(addr, desc, class, type, size, subflag, DSP);
231: printf("\n");
232: }
233:
234: /* display addr in instruction space using format desc or class s */
235: /* returns -1 if bad address */
236: dispi(addr, desc, class, type, size, subflag, space)
237: u_char class;
238: char *desc; short type; ADDR addr; {
239: register i;
240: i = dispx(addr, desc, class, type, size, subflag, ISP);
241: printf("\n");
242: return(i);
243: }
244:
245: char pd[3];
246: dispx(addr, desc, class, type, size, subflag, space)
247: u_char class;
248: char *desc; short type; ADDR addr; {
249: int i, sflag;
250: char *p;
251: char dlen, dfmt;
252: long value;
253: union {
254: char c[WORDSIZE];
255: int w;
256: float f;
257: } word;
258: union {
259: struct{
260: int w1, w2;
261: } ww;
262: double d;
263: } dbl;
264:
265: class &= STABMASK;
266: if (desc[0] == '\0') desc = typetodesc(type, subflag);
267: cpstr(odesc, desc);
268: otype = type;
269: oclass = class;
270: oaddr = addr;
271: oincr = 0;
272: if (debug) printf("dispx(addr=%d,desc=%s,class=%d,type=%d,size=%d,subflg=%d,space=%d)\n",
273: addr, desc, class, type, size, subflag, space);
274: pd[0] = '%';
275: pd[1] = dfmt = 'd';
276: dlen = '\0';
277: for (p = desc; *p; p++) {
278: if (*p>= '0' && *p<'9') {
279: size = readint(&p);
280: p--;
281: } else switch (*p) {
282: case 'l':
283: case 'h':
284: case 'b':
285: dlen = *p;
286: break;
287:
288: case 'a':
289: case 'c':
290: case 'd':
291: case 'f':
292: case 'g':
293: case 'i':
294: case 'I':
295: case 'o':
296: case 'p':
297: case 's':
298: case 'u':
299: case 'x':
300: pd[1] = dfmt = *p;
301: break;
302:
303: default:
304: printf("Illegal descriptor: %c\n", *p);
305: return(1);
306: }
307: }
308:
309: if (type == -1)
310: value = addr;
311: else if (class == N_RSYM && addr < 16) {
312: /* MACHINE DEPENDENT */
313: if ((addr > 0 && addr < 6) || addr > 11) {
314: printf("Bad register var %d\n", addr);
315: return(-1);
316: }
317: value = *(ADDR *)(((ADDR) &u) + R0 + (WORDSIZE)*addr);
318: }
319: else {
320: value = getval(addr, dfmt == 'g' ? 'd' : dfmt, space);
321: }
322:
323: if (errflg) {
324: printf("%s", errflg);
325: errflg = 0;
326: return(-1);
327: }
328:
329: switch (dfmt) {
330: default:
331: switch (dfmt) {
332: case 'u':
333: case 'x':
334: case 'o':
335: switch (dlen) {
336: case 'h':
337: value = (unsigned short) value;
338: oincr = 2;
339: break;
340: case 'b':
341: value = (unsigned char) value;
342: oincr = 1;
343: break;
344: case 'l':
345: value = (unsigned long) value;
346: oincr = 4;
347: break;
348: default:
349: oincr = WORDSIZE;
350: break;
351: }
352: break;
353:
354: default:
355: switch (dlen) {
356: case 'h':
357: value = (short) value;
358: oincr = 2;
359: break;
360: case 'b':
361: value = (char) value;
362: oincr = 1;
363: break;
364: case 'l':
365: value = (long) value;
366: oincr = 4;
367: break;
368: default:
369: oincr = WORDSIZE;
370: break;
371: }
372: }
373: if (dfmt == 'x' && (value > 9 || value < 0))
374: printf("0x");
375: else if (dfmt == 'o' && (value > 7 || value < 0))
376: printf("0");
377: printf(pd, value);
378: return(1);
379:
380: case 'f':
381: pd[1] = 'g';
382: word.w = value;
383: printf(pd, word.f);
384: return(1);
385:
386: case 'g':
387: dbl.ww.w1 = value;
388: dbl.ww.w2 = (class == N_RSYM) ?
389: *(ADDR *)(((ADDR) &u)+R0+(WORDSIZE)*(addr+1)) :
390: getval(addr+WORDSIZE, 'd', space);
391: printf("%.13g", dbl.d);
392: return(1);
393:
394: case 'p':
395: printf("%s:%d", adrtoprocp(value)->pname,
396: adrtolineno(value));
397: return(1);
398:
399: case 's':
400: addr = getindir(class, addr, type);
401: goto aa;
402:
403: case 'c':
404: if (size <= 1) {
405: oincr = 1;
406: printchar(value);
407: return(1);
408: } else
409: goto aa;
410:
411: case 'a':
412: aa: sflag = size == 0;
413: if (sflag)
414: size = 128; /* maximum length for s and a */
415: else
416: oincr = size;
417: for (;;) {
418: word.w = getval(addr, 'd', space);
419: for (i=0; i<WORDSIZE; i++) {
420: if (sflag && word.c[i] == 0)
421: return(1);
422: if (size-- == 0)
423: return(1);
424: printchar(word.c[i]);
425: }
426: addr += WORDSIZE;
427: }
428: break;
429:
430: case 'i':
431: case 'I':
432: value = chkget(dot, space);
433: if (errflg) {
434: printf("%s", errflg);
435: errflg = 0;
436: return(-1);
437: }
438: printins(dfmt, space, value);
439: break;
440:
441: }
442: return(1);
443: }
444:
445: /* print variable as in prvar */
446: printit(metaflag, prvar, addr, desc, class, type, size, subflag, space)
447: u_char class;
448: char *desc; short type; ADDR addr; {
449: if (prvar == 0)
450: return;
451: if (metaflag) {
452: if (prvar == 1)
453: printf("/ ");
454: else
455: printf("= ");
456: }
457: if (prvar == 1)
458: dispf(addr, desc, class, type, size,
459: subflag, space);
460: else
461: dispf(addr, desc, 0, -1, 0, 0, DSP);
462: }
463:
464: printchar(c) {
465: if ((c & 0177) < ' ')
466: printf("^%c", c + ('A' - 1));
467: else if ((c & 0177) == 0177)
468: printf("^?");
469: else
470: printf("%c", c);
471: }
472:
473: INT fcor;
474: printmap(s,amap)
475: STRING s; MAP *amap;
476: {
477: int file;
478: file=amap->ufd;
479: printf("%s\t`%s'\n",s,(file<0 ? "-" : (file==fcor ? corfil : symfil)));
480: printf("b1 = 0x%-16x",amap->b1);
481: printf("e1 = 0x%-16x",amap->e1);
482: printf("f1 = 0x%-x",amap->f1);
483: printf("\nb2 = 0x%-16x",amap->b2);
484: printf("e2 = 0x%-16x",amap->e2);
485: printf("f2 = 0x%-x",amap->f2);
486: printf("\n");
487: }
488:
489: #define NUMREGS 24 /* number of hardware registers */
490: REGLIST reglist[];
491:
492: printregs()
493: {
494: REG REGPTR p;
495:
496: for (p=reglist; p < ®list[NUMREGS/2]; p++) {
497: printf("%4.4s/ ", p->rname);
498: prhex12(*(ADDR *)(((ADDR)&u)+p->roffs));
499: printf(" %4.4s/ ",(p+NUMREGS/2)->rname);
500: prhex(*(ADDR *)(((ADDR)&u)+(p+NUMREGS/2)->roffs));
501: printf("\n");
502: }
503: printpc();
504: }
505:
506: printpc()
507: {
508: dot= *(ADDR *)(((ADDR)&u)+PC);
509: prisploc();
510: printins('i',ISP,chkget(dot,ISP));
511: printf("\n");
512: }
513:
514: /* print register */
515: REGLIST reglist[];
516: regout(name, prvar, fmt)
517: char *name, *fmt; {
518: REG REGPTR p;
519: for (p=reglist; p< ®list[24]; p++) {
520: if (eqstr(name, p->rname)) {
521: printit(0, prvar, *(ADDR *)(((ADDR)&u)+p->roffs),
522: fmt[0] ? fmt : "d", N_GSYM, -1, 0, 0, DSP);
523: return(p->roffs);
524: }
525: }
526: error("Unknown register variable");
527: return(-1);
528: }
529: /* Print symbolic location of dot */
530: prisploc() {
531: struct proct *procp;
532: int lineno;
533:
534: printf("0x%x", dot);
535: procp = adrtoprocp(dot);
536: if (procp != badproc) {
537: printf(" (");
538: prlnoff(procp, dot);
539: printf("): \t");
540: } else
541: printf(": \t");
542: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.