![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to format.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / cdb|
Return to format.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / cdb |
1.1 root 1: static char sccsid[] = "@(#)format.c 2.12";
2:
3: #include <ctype.h>
4: #include "macdefs.h"
5: #include "cdb.h"
6:
7: export int vcNest; /* nesting level for printg structures and unions */
8: export char vsbFmt[20]; /* format spec for addresses */
9: static char vsbAdr[20]; /* where we stick last address formatted - SbFAdr */
10:
11: char *vmpBtSb[] = { /* map basic types into the type names */
12: "undefined",
13: "Function Argument",
14: "char",
15: "short",
16: "int",
17: "long",
18: "float",
19: "double",
20: "struct",
21: "union",
22: "enum",
23: "member of enum",
24: "unsigned char",
25: "unsigned short",
26: "unsigned int",
27: "unsigned long"
28: };
29:
30:
31: /* S B F A D R */
32:
33: export char * SbFAdr(adrLong, fMask)
34: long adrLong;
35: FLAGT fMask;
36: {
37: if (vsbFmt[0] == chNull)
38: strcpy(vsbFmt, "%lx");
39: #if (CBINT == CBSHORT)
40: if (fMask)
41: adrLong &= 0x0000ffffL;
42: #endif
43: sprintf(vsbAdr, vsbFmt, adrLong);
44: return(vsbAdr);
45: } /* SbFAdr */
46:
47:
48: /* D F F T Y */
49:
50: export DFE DfFTy(ty, fAlternate)
51: pTYR ty;
52: FLAGT fAlternate;
53: {
54: int tq;
55:
56: tq = TqFTy(ty, 1);
57: if ((tq == tqPtr) OR (tq == tqArray)) {
58: if ( fAlternate
59: AND (ty->td.bt == btChar)
60: AND ((tq == tqArray AND TqFTy(ty, 2) == tqNil)
61: OR (ty->td.tq1 == tqPtr)) ) {
62: return((tq == tqPtr) ? dfPStr : dfStr); /* so it looks pretty */
63: } /* if */
64: return(dfAddr); /* use address display mode */
65: } /* if */
66:
67: if (ty->td.st == stReg)
68: return(dfAddr); /* a hackers delight */
69:
70: switch (ty->td.bt) {
71: case btNil:
72: return(dfNil);
73: case btUnion:
74: case btStruct:
75: if (fAlternate)
76: #ifdef BSD42
77: return(dfStruct);
78: #else
79: return(dfAddr);
80: #endif
81: else
82: return(dfAddr);
83: case btUChar:
84: case btUInt:
85: case btULong:
86: return(dfUnsigned);
87: case btShort:
88: case btInt:
89: case btLong:
90: return(dfDecimal);
91: case btFloat:
92: case btDouble:
93: return(dfGFloat);
94: case btEType:
95: return(dfEnum);
96: case btChar:
97: if (tq == tqArray AND fAlternate)
98: return(dfStr);
99: else
100: return(dfChar);
101: } /* switch */
102: return(dfDecimal);
103: } /* DfFTy */
104:
105:
106: /* C B F C H */
107:
108: export int CbFCh(ch)
109: char ch;
110: {
111: switch (ch) {
112: case 'b':
113: case 'c':
114: return(1);
115: case 'e':
116: case 'f':
117: case 'g':
118: return(CBFLOAT);
119: case 'E':
120: case 'F':
121: case 'G':
122: return(CBDOUBLE);
123: case 'D':
124: case 'O':
125: case 'U':
126: case 'X':
127: return(CBLONG);
128: case 'd':
129: case 'o':
130: case 'u':
131: case 'x':
132: case 'a':
133: case 'n':
134: case 'p':
135: case 's':
136: case 'B':
137: case 'C':
138: case 'S':
139: return(-1); /* says to use `current' size */
140: } /* switch */
141: return(-1);
142: } /* CbFCh */
143:
144:
145: /* D F F C H */
146:
147: export DFE DfFCh(ch)
148: char ch;
149: {
150: switch (ch) {
151: case 'a':
152: return(dfStr);
153: case 'C':
154: case 'c':
155: return(dfChar);
156: case 'b':
157: case 'D':
158: case 'd':
159: return(dfDecimal);
160: case 'E':
161: case 'e':
162: return(dfEFloat);
163: case 'F':
164: case 'f':
165: return(dfFFloat);
166: case 'G':
167: case 'g':
168: return(dfGFloat);
169: case 'n':
170: return(dfNil);
171: case 'O':
172: case 'o':
173: return(dfOctal);
174: case 'p':
175: return(dfProc);
176: case 'S':
177: return(dfStruct);
178: case 's':
179: return(dfPStr);
180: case 'U':
181: case 'u':
182: return(dfUnsigned);
183: case 't':
184: return(dfType);
185: case 'X':
186: case 'x':
187: return(dfHex);
188: } /* switch */
189: return(dfNil);
190: } /* DfFCh */
191:
192:
193: /* G E T M O D E */
194:
195: export void GetMode(mode)
196: pMODER mode;
197: {
198: char ch;
199: TKE tk;
200:
201: /* consider the next few tokens as variable formatting info */
202: /* NOTE: we assume WE get next token!! */
203: tk = TkNext();
204: mode->imap = 0;
205: if (tk == tkStar) {
206: mode->imap = 1;
207: tk = TkNext();
208: } /* if */
209: if (tk == tkNil) {
210: return;
211: }
212: else if (tk == tkNumber) {
213: mode->cnt = atoi(vsbTok);
214: tk = TkNext();
215: }
216: else {
217: mode->cnt = 1;
218: } /* if */
219:
220: if (tk == tkStr) {
221: ch = vsbTok[0];
222: /* determine # of bytes based on format */
223: mode->len = CbFCh(ch);
224: mode->df = DfFCh(ch);
225: if (vsbTok[1] != chNull)
226: mode->len = (vsbTok[1] == 'b') ? 1 :
227: (vsbTok[1] == 's') ? 2 :
228: (vsbTok[1] == 'l') ? 4 : atoi(&vsbTok[1]);
229: tk = TkNext();
230: } /* if */
231: } /* GetMode */
232:
233:
234: /* I N C F T Y M O D E */
235:
236: export int IncFTyMode(ty, mode)
237: pTYR ty;
238: pMODER mode;
239: {
240: int i;
241:
242: if ((ty->td.st == stSpc) /* we do NOT allow inc's of specials */
243: OR (mode->df == dfType))
244: return(0);
245:
246: #ifdef BSD41
247: ty->sbVar = -1; /* because this name is no longer correct */
248: #else
249: ty->sbVar[0] = chNull; /* because this name is no longer correct */
250: #endif
251: if (ty->td.st == stReg) {
252: return(1);
253: }
254: else {
255: if (mode->df == dfStr) {
256: if (mode->len < 0) {
257: i = -mode->len;
258: mode->len = -1;
259: return(i);
260: }
261: else {
262: return(mode->cnt * mode->len);
263: } /* if */
264: }
265: else if (mode->df == dfPStr) {
266: return(mode->cnt * CBPOINT);
267: }
268: else {
269: return(mode->cnt * mode->len);
270: } /* if */
271: } /* if */
272: } /* IncFTyMode */
273:
274:
275: /* D I S P V A L */
276:
277: export void DispVal(adrLong, tyIn, mode, fShowAdr, fIndirect, fAlternate)
278: long adrLong;
279: pTYR tyIn;
280: pMODER mode;
281: FLAGT fShowAdr, fIndirect, fAlternate;
282: {
283: int modval, width, cPrint, cb;
284: int len, cnt, i;
285: FLAGT fConstant, fCheckNull, fRandomLength;
286: char ch, *sbVar;
287: long mask, val, *pKludge;
288: double valDouble;
289: DFE df;
290: STUFFU stuff;
291: MODER amodeTemp;
292: ADRT adrWorking;
293: #if (CBINT == CBSHORT)
294: short valMasked;
295: #else
296: long valMasked;
297: #endif
298:
299: modval = 1;
300: /* if the mode is supplied, we ignore the TY, else we use it to build
301: * a plausible display format.
302: */
303: if (mode == modeNil) {
304: mode = &amodeTemp;
305: cnt = 1;
306: df = dfNil;
307: }
308: else {
309: df = mode->df;
310: cnt = mode->cnt;
311: len = mode->len;
312: /* this may not be right, but we need to force the size of what we
313: * are looking at to be the size we requested in the format.
314: * this way, when we say `sbWord/c;<cr>;<cr>;.='H' ' we actually
315: * do the `correct' character assignment.
316: */
317: if (len > 0) {
318: switch (len) {
319: case 1:
320: CopyTy(tyIn, vtyChar);
321: if (df == dfUnsigned)
322: tyIn->td.bt = btUChar;
323: break;
324: case 2:
325: CopyTy(tyIn, vtyShort);
326: if (df == dfUnsigned)
327: tyIn->td.bt = btUShort;
328: break;
329: case 4:
330: CopyTy(tyIn, vtyLong);
331: if (df == dfUnsigned)
332: tyIn->td.bt = btULong;
333: break;
334: } /* switch */
335: } /* if */
336: } /* if */
337:
338: if (df == dfNil) {
339: /* they did not specify display format */
340: df = DfFTy(tyIn, fAlternate);
341: len = (df == dfStr OR df == dfPStr) ? -1 : CbFTy(tyIn);
342: /* remember this stuff */
343: mode->df = df;
344: mode->cnt = cnt;
345: mode->len = len;
346: } /* if */
347: fRandomLength = (len == -1);
348: if ((len == -1)
349: AND (df != dfStr)
350: AND (df != dfPStr))
351: mode->len = len = CbFTy(tyIn);
352:
353: #ifdef ONYX
354: /* we may want to do this for other than ONYX, too. */
355: if (FOdd(adrLong))
356: cb = 1; /* we assume it is actually a single byte */
357: #endif
358: cb = len;
359: mask = -1;
360: if (df == dfPStr) {
361: cb = CBPOINT;
362: }
363: else if (df == dfStr) {
364: cb = CBCHAR;
365: if (fRandomLength)
366: mode->len = 0; /* we will stuff final count in here for Inc */
367: }
368: else if (df == dfProc) {
369: fShowAdr = false;
370: fIndirect = false;
371: }
372: else {
373: /* here we try to skull out a good width for this size */
374: width = 7;
375: modval = 8;
376: if (len == 1)
377: mask = 0x00ff;
378: else if (len == 2)
379: mask = 0xffff;
380: else if (len == 4) {
381: mask = 0xffffffff;
382: width = 12;
383: modval = 4;
384: } /* if */
385: } /* if */
386:
387: if (cnt == 1)
388: width = 0; /* we don't try to add anything if there's just one */
389:
390: if (df == dfType) {
391: fIndirect = false;
392: fShowAdr = false;
393: } /* if */
394: cPrint = 0;
395: while (cnt--) {
396: vimap = mode->imap; /* sorta kludgey - sorry */
397: /*
398: fConstant = tyIn->td.fConstant;
399: tyIn->td.fConstant = false;
400: */
401: val = (fIndirect) ? ValFAdr(adrLong, tyIn) : adrLong;
402: /*
403: tyIn->td.fConstant = fConstant;
404: */
405: vimap = 0;
406: valMasked = val & mask;
407: if (cb < 4)
408: val = valMasked;
409: adrWorking = adrLong;
410: if (fShowAdr
411: AND fIndirect
412: AND (!tyIn->td.fConstant)
413: AND (cPrint % modval == 0)) {
414: if ((cPrint == 0)
415: AND (tyIn != tyNil)
416: AND (*(sbVar = SbInCore(tyIn[0].sbVar)) != chNull)
417: AND (*sbVar != '*'))
418: #ifdef BSD41
419: printf("%s = ", sbVar);
420: #else
421: printf("%.8s = ", sbVar);
422: #endif
423: else
424: printf("%s ", SbFAdr(adrLong, true));
425: } /* if */
426: switch (df) {
427: case dfType:
428: PxTy(tyIn);
429: break;
430: case dfAddr:
431: printf("%*s", width, SbFAdr(val, true));
432: break;
433: case dfDecimal:
434: printf("%*ld", width, val);
435: break;
436: case dfUnsigned:
437: val &= mask;
438: printf("%*lu", width, val);
439: break;
440: case dfOctal:
441: val &= mask;
442: printf("%*lo", width, val);
443: break;
444: case dfHex:
445: val &= mask;
446: printf("%*lx", width, val);
447: break;
448: case dfChar:
449: if (valMasked < ' ')
450: printf("^%c (%o)", valMasked+0100, valMasked);
451: else printf("%c", valMasked);
452: break;
453: case dfFFloat:
454: case dfEFloat:
455: case dfGFloat:
456: /* the following tries to get the right
457: * conversions to happen.
458: */
459: if (cb == 4) {
460: stuff.lng = val;
461: valDouble = stuff.fl;
462: }
463: else { /* we assume double */
464: pKludge = (long *)&valDouble;
465: pKludge[0] = val;
466: pKludge[1] = ValFAdr(adrLong+4, vtyLong);
467: } /* if */
468: if (df == dfFFloat)
469: printf("%f", valDouble);
470: else if (df == dfEFloat)
471: printf("%e", valDouble);
472: else
473: printf("%g", valDouble);
474: break;
475: case dfEnum:
476: PxEnum(val, tyIn);
477: break;
478: case dfStruct:
479: IssFPxStruct(adrWorking, tyIn, true);
480: break;
481: case dfProc:
482: PrintPos(valMasked, fmtFile+fmtProc+fmtLn+fmtPrint+fmtSave);
483: break;
484: case dfPStr:
485: adrWorking = valMasked; /* and fall through */
486: case dfStr:
487: fCheckNull = false;
488: if (fRandomLength) {
489: if (adrWorking == 0) {
490: printf("<null pointer>");
491: break;
492: } /* if */
493: len = 128;
494: fCheckNull = true;
495: } /* if */
496: printf("\"");
497: for (i=0; i != len; i++) {
498: ch = GetByte((ADRT)(adrWorking+i), spaceData);
499: if ((ch == chNull) AND fCheckNull)
500: break;
501: if (ch < ' ')
502: printf("^%c", ch+0100);
503: else printf("%c", ch);
504: } /* for */
505: printf("\"");
506: break;
507: } /* switch */
508:
509: if (fRandomLength) {
510: i += 1; /* if we did /s or /a, this moves us past the chNull */
511: if (df == dfStr)
512: mode->len -= i; /* remember size for IncFTyMode */
513: } /* if */
514:
515: /* advance */
516: if (cnt) {
517: #ifdef BSD41
518: tyIn->sbVar = -1; /* because this name is no longer correct */
519: #else
520: tyIn->sbVar[0] = chNull;/* because this name is no longer correct */
521: #endif
522:
523: adrLong += (df == dfStr) ? i : CbFTy(tyIn);
524: if (((++cPrint % modval) == 0)
525: OR (df == dfPStr OR df == dfStr OR df == dfStruct)) {
526: printf("\n");
527: } /* if */
528: } /* if */
529: } /* while */
530: } /* DispVal */
531:
532:
533: /* P X E N U M */
534:
535: export void PxEnum(val, ty)
536: long val;
537: pTYR ty;
538: {
539: #ifndef BSD42
540: printf("%ld", val);
541: #else
542: int i;
543: char *sb, *sbName, *sbType, sbLook[10];
544: pXTYR xty;
545:
546: xty = (pXTYR) (ty + 1);
547: sbType = SbInCore(xty->issRef);
548: sbName = SbInCore(SbSafe(sbType));
549: sprintf(sbLook, ":%d,", val); /* value we are looking for */
550: i = IFSbSb(sbType, sbLook);
551: if (i == -1) {
552: printf("Value %d is not defined for 'enum %s'", val, sbName);
553: return;
554: }
555: sb = sbType + i - 1;
556: /* got it - now back up to before the name */
557: while ((*sb != ',') AND (*sb != '='))
558: sb--;
559: if (*sb == '=')
560: sb++; /* point past 'e' */
561: sb++; /* past the ',' or the '=' */
562: printf("%s", SbInCore(SbSafe(sb)));
563: #endif
564: } /* PxEnum */
565:
566:
567: /* I S S F P X S T R U C T */
568:
569: export long IssFPxStruct(adr, tyStruct, fDoVal)
570: ADRT adr;
571: pTYR tyStruct;
572: FLAGT fDoVal;
573: {
574: #ifndef BSD42
575: UError("There is insufficient information to do a structure dump");
576: #else
577: int i;
578: long adrLong, iss;
579: char chType, *sb, *sbName, *sbEqual, *sbType, sbLook[10];
580: char sbStart[1000]; /* where we stash the type info */
581: FLAGT fDidit;
582: TYR tyField[cTyMax], tyT[cTyMax];
583: pXTYR xty;
584:
585: xty = (pXTYR) (tyStruct + 1);
586: if (xty->st != stExtend) {
587: adrLong = adr;
588: printf("%s", SbFAdr(adrLong));
589: return(-1);
590: }
591: iss = xty->issRef;
592: strcpy(sbStart, SbInCore(iss));
593: sbType = sbStart;
594: sbName = SbInCore(SbSafe(sbType));
595: i = IFSbSb(sbType, "=");
596: sbType += i + 1;
597: if ((i == -1)
598: OR ((*sbType != 's') AND (*sbType != 'u')) )
599: UError("This does not appear to be a stuct or union");
600: chType = *sbType++;
601: while (isdigit(*sbType)) /* get past size value */
602: sbType++;
603: printf("%s %s {\n", (chType == 's') ? "struct" : "union", sbName);
604: vcNest++; /* kick nesting level for indent printing */
605: while (*sbType) {
606: sbName = SbInCore(SbSafe(sbType));
607: #ifdef BSD41
608: tyField[0].sbVar = bitHigh | (long)sbName;
609: #else
610: strncpy(tyField[0].sbVar, sbName, cbVarMax);
611: #endif
612: tyField[0].td.st = stStruct;
613: adrLong = adr;
614: adrLong = AdrFField(adrLong, tyStruct, tyField);
615: sbEqual = strchr(sbType, '=');
616: sb = sbType; /* remember where we are in case of imbeded struct */
617: sbType = strchr(sbType, ';') + 1;
618: fDidit = false;
619: if ((sbEqual != sbNil) AND (sbEqual < sbType)) {
620: if (*++sbEqual == 'a') {
621: /* this should get us through the array declaration */
622: sbType = strchr(sbEqual, ';') + 1;
623: sbType = strchr(sbType, ';') + 1;
624: sbType = strchr(sbType, ';') + 1;
625: sbType = strchr(sbType, ';') + 1; /* this should be next name */
626: }
627: else if (*sbEqual == 's') {
628: /* we have a struct, recurse */
629: xty = (pXTYR) (tyField + 1);
630: xty->issRef = iss + (sb - sbStart);
631: for (i=0; i<vcNest; i++)
632: printf(" ");
633: iss = IssFPxStruct(adrLong, tyField, fDoVal);
634: printf("\n");
635: strcpy(sbStart, SbInCore(iss));
636: sbType = sbStart;
637: sbType = strchr(sbType, ';') + 1; /* this should be next name */
638: fDidit = true;
639: }
640: }
641: if (!fDidit) {
642: for (i=0; i<vcNest; i++)
643: printf(" ");
644: if (fDoVal)
645: DispVal(adrLong, tyField, modeNil, true, true, true);
646: else
647: PxTy(tyField);
648: printf(";\n");
649: }
650: if (*sbType == ';')
651: break; /* end of the line */
652: } /* while */
653: for (i=0; i<vcNest; i++)
654: printf(" ");
655: vcNest--;
656: printf("};");
657: return(iss+sbType-sbStart+1); /* points 1 past ending ';;' */
658: #endif
659: } /* IssFPxStruct */
660:
661:
662: /* P X T Y */
663:
664: export void PxTy(ty)
665: pTYR ty;
666: {
667: int ipd, i, j, tq, tqLast, st, bt;
668: short *rgDim;
669: FLAGT fDidName, fHaveExtension, fNeedRP;
670: pXTYR xty;
671:
672: tqLast = tqNil;
673: fDidName = false;
674: st = ty->td.st;
675: bt = ty->td.bt;
676: xty = (pXTYR)(ty+1);
677: fHaveExtension = (xty->st == stExtend);
678: rgDim = xty->rgDim;
679:
680: #ifdef BSD41
681: if (ty->td.st == stProc) {
682: /* BSD 4.1 does not know return type for procedures */
683: ipd = IpdFName(SbInCore(ty->sbVar));
684: DispFrame(adrNil,ipd, adrNil, adrNil, -1, false, false);
685: return;
686: }
687: #ifdef BSD42
688: tq = TqFTy(ty, 1);
689: if ((tq == tqNil)
690: AND ((bt == btStruct)
691: OR (bt == btUnion))) {
692: IssFPxStruct(0L, ty, false);
693: fDidName = true;
694: }
695: else {
696: /* print type name */
697: printf("%s ", vmpBtSb[bt]);
698: if ((bt == btEType)
699: OR (bt == btStruct)
700: OR (bt == btUnion)) {
701: printf("%s ",SbInSafe(xty->issRef));
702: }
703: }
704: #else
705: /* print type name */
706: printf("%s ", vmpBtSb[bt]);
707: #endif
708: #else
709: /* print type name */
710: printf("%s ", vmpBtSb[bt]);
711: #endif
712: fNeedRP = false;
713: tqLast = tqNil;
714: for (i=1; i<=6; i++) {
715: if ((tq = TqFTy(ty, i)) == tqNil)
716: break;
717: if ((tqLast != tqNil)
718: AND (tq != tqLast)) {
719: printf("(");
720: fNeedRP = true;
721: } /* if */
722: switch (tq) {
723: case tqPtr:
724: printf("*");
725: break;
726: case tqFunc:
727: ipd = IpdFName(SbInCore(ty->sbVar));
728: DispFrame(adrNil,ipd, adrNil, adrNil, -1, false, false);
729: fDidName = true; /* printed by DispFrame */
730: return;
731: case tqArray:
732: if (!fDidName) {
733: printf("%s", SbInCore(ty->sbVar));
734: fDidName = true;
735: } /* if */
736: if (fHaveExtension) {
737: for (j=0; (j < 2) AND (rgDim[j] != 0); j++) {
738: if (rgDim[j] < 0)
739: printf("[]");
740: else
741: printf("[%d]", rgDim[j]+1);
742: }
743: }
744: else {
745: printf("[]");
746: }
747: break;
748: } /* switch */
749: if (fNeedRP) {
750: fNeedRP = false;
751: printf(")");
752: }
753: tqLast = tq;
754: } /* for */
755: if (!fDidName)
756: printf("%s", SbInCore(ty->sbVar));
757: if (ty->td.width != 0)
758: printf(" : %d", ty->td.width);
759: } /* PxTy */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.