![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ty.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 ty.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / cdb |
1.1 root 1: static char sccsid[] = "@(#)ty.c 2.16";
2:
3: #include <ctype.h>
4: #include "cdb.h"
5: #include "macdefs.h"
6:
7: #ifdef BSD41
8: #define crockValue -1
9: #define cbSbSafe 1024
10: #else
11: #define crockValue ""
12: #define cbSbSafe 256
13: #endif
14: char vsbSafe[cbSbSafe]; /* where we stick names of things */
15: char *vsbNextSafe = vsbSafe; /* next available place */
16:
17: /* v - that is the fConstant field */
18: #ifdef SUN
19: TYR atyCnChar = {
20: crockValue, stValue, true, 0, 0,0,0,0,0,0, btChar, 0};
21: TYR atyChar = {
22: crockValue, stValue, false, 0, 0,0,0,0,0,0, btChar, 0};
23: TYR atyCnShort ={
24: crockValue, stValue, true, 0, 0,0,0,0,0,0, btShort, 0};
25: TYR atyShort = {
26: crockValue, stValue, false, 0, 0,0,0,0,0,0, btShort, 0};
27: TYR atyCnInt = {
28: crockValue, stValue, true, 0, 0,0,0,0,0,0, btInt, 0};
29: TYR atyInt = {
30: crockValue, stValue, false, 0, 0,0,0,0,0,0, btInt, 0};
31: TYR atyCnLong = {
32: crockValue, stValue, true, 0, 0,0,0,0,0,0, btLong, 0};
33: TYR atyLong = {
34: crockValue, stValue, false, 0, 0,0,0,0,0,0, btLong, 0};
35: TYR atyCnFloat ={
36: crockValue, stValue, true, 0, 0,0,0,0,0,0, btFloat, 0};
37: TYR atyFloat = {
38: crockValue, stValue, false, 0, 0,0,0,0,0,0, btFloat, 0};
39: #else
40: TYR atyCnChar = {
41: crockValue, stValue, true, 0, btChar, 0,0,0,0,0,0, 0};
42: TYR atyChar = {
43: crockValue, stValue, false, 0, btChar, 0,0,0,0,0,0, 0};
44: TYR atyCnShort ={
45: crockValue, stValue, true, 0, btShort, 0,0,0,0,0,0, 0};
46: TYR atyShort = {
47: crockValue, stValue, false, 0, btShort, 0,0,0,0,0,0, 0};
48: TYR atyCnInt = {
49: crockValue, stValue, true, 0, btInt, 0,0,0,0,0,0, 0};
50: TYR atyInt = {
51: crockValue, stValue, false, 0, btInt, 0,0,0,0,0,0, 0};
52: TYR atyCnLong = {
53: crockValue, stValue, true, 0, btLong, 0,0,0,0,0,0, 0};
54: TYR atyLong = {
55: crockValue, stValue, false, 0, btLong, 0,0,0,0,0,0, 0};
56: TYR atyCnFloat ={
57: crockValue, stValue, true, 0, btFloat, 0,0,0,0,0,0, 0};
58: TYR atyFloat = {
59: crockValue, stValue, false, 0, btFloat, 0,0,0,0,0,0, 0};
60: #endif
61: TYR atyZeros;
62:
63: export pTYR vtyZeros;
64: export pTYR vtyChar, vtyCnChar;
65: export pTYR vtyShort, vtyCnShort;
66: export pTYR vtyInt, vtyCnInt;
67: export pTYR vtyLong, vtyCnLong;
68: export pTYR vtyFloat, vtyCnFloat;
69:
70: /* most of this type code is NOT needed if we have berkely symbol tables */
71: #ifndef BSD41
72: export int vityMac; /* # TY's in current decl file */
73: int vityBase, vityLim; /* bounds on the ty cache */
74: int vcTyCache; /* # of things actually in cache */
75: #define cTyCacheMax 100
76: TYR vtyCache[cTyCacheMax]; /* buffer where we stick type stuff */
77: int vity; /* index of TY of current interest */
78: pTYR vtyCur; /* TY of current interest */
79: #define cbTyCache sizeof(vtyCache)
80:
81: #define fDoForward true
82: #define fDoBackward false
83:
84: /* S E T T Y C A C H E */
85:
86: local void SetTyCache(ity)
87: int ity;
88: {
89: int ityTemp, cRead;
90: long l1, l2, offset;
91:
92: if ( ((ity >= vityBase) AND (ity < vityLim-(cTyMax-1)))
93: OR ((ity == vityLim-(cTyMax-1)) AND (vityLim == vityMac)) ) {
94: return; /* it is already in there, somewhere */
95: } /* if */
96: ityTemp = (ity / cTyCacheMax) * cTyCacheMax; /* adjust to 'page' boundary */
97: if ((ity+(cTyMax-1)) % cTyCacheMax == 0)
98: ityTemp += (cTyMax-1); /* allow room for a possible second TYR */
99: l1 = ityTemp;
100: l2 = cbTYR;
101: offset = l1 * l2;
102: if (lseek(vfnDecl, offset, 0) < 0L) {
103: Panic("Bad seek in SetTyCache");
104: } /* if */
105: if ((cRead=read(vfnDecl, vtyCache, cbTyCache)) < 0)
106: Panic("Bad read in SetTyCache");
107: vcTyCache = cRead / cbTYR;
108: vityBase = ityTemp;
109: vityLim = vityBase + vcTyCache;
110: } /* SetTyCache */
111:
112:
113: /* S E T T Y */
114:
115: local void SetTy(ity)
116: int ity;
117: {
118: if (ity < 0 OR ity >= vityMac)
119: Panic("ity out of bounds in SetTy - %d", ity);
120: vity = ity;
121: SetTyCache(ity);
122: vtyCur = vtyCache + (ity-vityBase);
123: } /* SetTy */
124:
125:
126: /* S E T T Y N E X T */
127:
128: local void SetTyNext(ity, fForward)
129: FLAGT fForward;
130: {
131: if ((ity < 0) OR (ity >= vityMac))
132: Panic("ity out of bounds in SetTyNext - %d", ity);
133: vity = ity + ((fForward) ? -1 : 1);
134: if (vity < 0)
135: vity = 0;
136: else if (vity >= vityMac)
137: vity = vityMac - 1;
138: SetTy(vity);
139: } /* SetTyNext */
140:
141:
142: /* F N E X T T Y */
143:
144: local FLAGT FNextTy(fForward, sbVar, stLook1, stLook2, stStop1, stStop2)
145: FLAGT fForward;
146: char *sbVar;
147: int stLook1, stLook2, stStop1, stStop2;
148: {
149: int i, st, ityEnd, dity, ity;
150:
151: if (vityMac == 0)
152: return(false); /* there is no valid decl file open */
153: dity = (fForward) ? 1 : -1;
154: ity = vity + dity;
155: while ((ity >= 0) AND (ity < vityMac)) {
156: SetTyCache(ity);
157: ityEnd = (fForward) ? vityLim : vityBase-1;
158: for (i = ity; ity != ityEnd; i+=dity, ity+=dity) {
159: vtyCur = vtyCache + i;
160: st = vtyCur->td.st & 0x00ff;
161: if ( (st == stLook1)
162: OR (st == stLook2)
163: OR ((sbVar != sbNil)
164: AND (stLook1 == 0)
165: AND (stLook2 == 0))) {
166: if ((sbVar == sbNil)
167: OR (FProcCmp(vtyCur->sbVar, sbVar)) ) {
168: SetTy(ity);
169: return(true);
170: } /* if */
171: }
172: else if (st == stStop1 OR st == stStop2) {
173: return(false);
174: } /* if */
175: } /* for */
176: } /* while */
177: return(false);
178: } /* FNextTY */
179:
180:
181: /* I T Y F S B L N */
182:
183: local int ItyFSbLn(sbVar, ln)
184: char *sbVar;
185: int ln;
186: {
187: int ity;
188: FLAGT fFoundBlock;
189:
190: if ((vfnDecl == fnNil)
191: OR (ln <= 0))
192: return(ityNil);
193:
194: /* first we find a block mark with a line number GREATER than ln */
195: SetTyNext(0, fDoForward);
196: fFoundBlock = false;
197: while (FNextTy(fDoForward, sbNil, stLBrac, stRBrac, 0, 0)) {
198: if (vtyCur->valTy > ln) {
199: fFoundBlock = true;
200: break;
201: } /* if */
202: } /* while */
203: if (!fFoundBlock) {
204: /* this could happen when looking for a formal of the
205: * last procedure in a file, and the procedure does not have
206: * any locals.
207: */
208: ity = vityMac-1; /* this might not be quite right - kludge */
209: SetTyNext(ity, fDoBackward);
210: } /* if */
211:
212: /* now we back up and find the name (if it's there) */
213: if (FNextTy(fDoBackward, sbVar, 0, 0, 0, 0)) {
214: return(vity);
215: } /* if */
216: return(ityNil);
217: } /* ItyFSbLn */
218:
219:
220: /* I N I T T Y C A C H E */
221:
222: export void InitTyCache()
223: {
224: vityBase = 0;
225: vityLim = 0;
226: SetTyCache(0);
227: } /* InitTyCache */
228: #endif
229:
230:
231: /* S B S A F E */
232:
233: export SBT SbSafe(sb)
234: char *sb;
235: {
236: int i;
237: SBT sbRet;
238: char *sbT;
239:
240: /* this guy sticks names in a temporarily safe place */
241: /* find the null or : */
242: for (sbT = sb; *sbT != chNull; sbT++)
243: if (*sbT == ':')
244: break;
245: i = sbT - sb + 1;
246: if (vsbNextSafe+i >= vsbSafe+cbSbSafe)
247: /* would run off end of buffer */
248: vsbNextSafe = vsbSafe; /* reuse the buffer */
249: strncpy(vsbNextSafe, sb, i);
250: #ifdef BSD41
251: sbRet = bitHigh | (SBT)vsbNextSafe;
252: #else
253: sbRet = vsbNextSafe;
254: #endif
255: vsbNextSafe[i-1] = chNull;
256: vsbNextSafe += i;
257: return(sbRet);
258: } /* SbSafe */
259:
260:
261: /* S B I N S A F E */
262:
263: export char * SbInSafe(iss)
264: long iss;
265: {
266: return( SbInCore(SbSafe(SbInCore(iss))) );
267: }
268:
269:
270: #ifdef BSD42
271:
272: /* I S S F I D B */
273:
274: local long IssFIdb(idb, iss)
275: int idb;
276: long iss;
277: {
278: int ifd, cbTarget;
279: long isym, issMac;
280: char *sbSym, *sbT1, *sbT2, sbIdb[10];
281:
282: /* given a DBX type number and a maximum iss, find the
283: * definition of the type.
284: * Return the index into string space.
285: */
286:
287: /* first we find beginning of THIS file's symbols */
288: issMac = iss + 1;
289: ifd = vifdNil;
290: if (vifd != vifdNil) {
291: SetSym(vrgFd[vifd].isym);
292: if (vsymCur->sbSym < issMac) {
293: SetSym(vrgFd[vifd+1].isym);
294: if (vsymCur->sbSym >= issMac)
295: ifd = vifd;
296: }
297: }
298: if (ifd == vifdNil) {
299: for (ifd=0; ifd < vifdMac; ifd++) {
300: SetSym(vrgFd[ifd].isym);
301: if (vsymCur->sbSym >= issMac) {
302: ifd--;
303: break;
304: }
305: } /* for */
306: } /* if */
307: sprintf(sbIdb, "%d", idb);
308: cbTarget = strlen(sbIdb);
309: isym = vrgFd[ifd].isym
310: #ifdef SUN
311: + 12; /* skip file sym + standard 11 types*/
312: #else
313: + 13; /* skip file sym + standard 12 types*/
314: #endif
315: SetSym(isym);
316: while (vsymCur->sbSym < issMac) {
317: sbT1 = sbSym = SbInCore(vsymCur->sbSym);
318: while ((sbT2 = strchr(sbT1, '=')) != sbNil) {
319: /* a cadidate */
320: if (FHdrCmp(sbIdb, sbT2-cbTarget)) {
321: /* found it! */
322: return(vsymCur->sbSym + (1+(sbT2-sbSym)));
323: }
324: sbT1 = sbT2 + 1; /* move past '=', see if there is another one */
325: } /* while */
326: isym++;
327: SetSym(isym);
328: } /* while */
329: Panic("Can't find idb: %d in ifd: %d", idb, ifd);
330: } /* IssFIdb */
331:
332:
333: /* T Y F I D B */
334:
335: local void TyFIdb(rgTy, idb)
336: pTYR rgTy;
337: int idb;
338: {
339: int bt;
340: /* these are the standard DBX types */
341: switch (idb) {
342: case 1:
343: bt = btInt;
344: break;
345: case 2:
346: bt = btChar;
347: break;
348: case 3:
349: bt = btLong;
350: break;
351: case 4:
352: bt = btShort;
353: break;
354: case 5:
355: bt = btUChar;
356: break;
357: case 6:
358: bt = btUShort;
359: break;
360: case 7:
361: bt = btULong;
362: break;
363: case 8:
364: bt = btUInt;
365: break;
366: case 9:
367: bt = btFloat;
368: break;
369: case 10:
370: bt = btDouble;
371: break;
372: case 11:
373: bt = btNil;
374: break;
375: } /* switch */
376: rgTy->td.bt = bt;
377: } /* TyFIdb */
378:
379:
380: /* I S S F S T A R T */
381:
382: export long IssFStart(iss)
383: {
384: char *sb;
385: /* given an iss at the beginning of a struct, union or enum definition
386: * return the iss of the NAME of this thing
387: * We have something like "FOOR:t18=s12....." and iss is pointing
388: * at the 's' after the '='.
389: */
390: do {
391: sb = SbInCore(--iss);
392: }
393: while ((*sb != chNull) AND (*sb != ';'));
394: return(++iss);
395: } /* IssFStart */
396:
397:
398: /* T Y F S C A N D B X */
399:
400: local void TyFScanDbx(rgTy, iss)
401: pTYR rgTy;
402: long iss;
403: {
404: int i, idb;
405: char ch;
406: char *sb;
407: pXTYR xty;
408:
409: printf("TyFScanDBX caled with 0x%x and %d\n",rgTy, iss);
410: xty = (pXTYR) (rgTy + 1); /* in case anyone needs it */
411: while (true) {
412: sb = SbInCore(iss);
413: printf("-1- sb :%s:\n",sb);
414: ch = *sb;
415: switch (ch) {
416: case chNull:
417: case ',':
418: case ';':
419: return;
420: case '0':
421: case '1':
422: case '2':
423: case '3':
424: case '4':
425: case '5':
426: case '6':
427: case '7':
428: case '8':
429: case '9':
430: idb = atoi(sb);
431: printf("-2- idb : %d\n",idb);
432: while (isdigit(*sb)) {
433: sb++;
434: iss++;
435: }
436: printf("-3- iss:%d sb:%s:\n", iss,sb);
437: if (*sb == '=')
438: break; /* continue onwards */
439: if (idb <= 11) {
440: TyFIdb(rgTy, idb);
441: return;
442: }
443: else {
444: iss = IssFIdb(idb, iss);
445: }
446: continue;
447: break;
448: case '*':
449: FAdjTd(rgTy, tqPtr);
450: break;
451: case '=':
452: break;
453: case 'a':
454: /* we expect this to look like 'ar1;0;#1;#2;
455: * where 0 is the lower bounds (always for C),
456: * #1 is the upper bound,
457: * #2 is the element type (possibley another array)
458: */
459: sb++;
460: if ((*sb++ != 'r')
461: OR (*sb++ != '1')
462: OR (*sb++ != ';')
463: OR (*sb++ != '0')
464: OR (*sb++ != ';'))
465: Panic("Lost in array spec??");
466: iss += 6;
467: i = atoi(sb); /* get the size of the dimension */
468: while (isdigit(*sb) OR (*sb == '-')) {
469: sb++;
470: iss++;
471: }
472: if (*sb++ != ';')
473: Panic("Lost in array spec");
474: if (xty->rgDim[1] == 0) {
475: if (TqFTy(rgTy, 1) != tqArray)
476: FAdjTd(rgTy, tqArray);
477: xty->st = stExtend;
478: if (xty->rgDim[0] == 0)
479: xty->rgDim[0] = i;
480: else
481: xty->rgDim[1] = i;
482: }
483: /* we should have sb pointing at the type number.
484: * loop will continue and go find it for us.
485: */
486: break;
487: case 'e':
488: rgTy[0].td.bt = btEType;
489: xty->st = stExtend;
490: xty->issRef = IssFStart(iss);
491: return;
492: case 'f':
493: case 'F':
494: rgTy[0].td.st = stProc;
495: break;
496: case 'G':
497: rgTy[0].td.st = stGlobal;
498: break;
499: case 'v': /* 'vaires' parameter - i.e. REFerenced */
500: case 'p':
501: rgTy[0].td.st = stParam;
502: break;
503: case 'r': /* I don't know what this means!!! */
504: break;
505: case 'V': /* 'local' static */
506: case 'S': /* 'global' static */
507: rgTy[0].td.st = stStatic;
508: break;
509: case 's':
510: case 'u':
511: rgTy[0].td.bt = (ch == 's') ? btStruct : btUnion;
512: xty->st = stExtend;
513: xty->issRef = IssFStart(iss);
514: xty->cb = atoi(++sb); /* size in bytes */
515: return;
516: case 'T': /* tag - named type */
517: case 't': /* type */
518: break;
519: } /* switch */
520: iss++;
521: } /* while */
522: } /* TyFScanDbx */
523:
524:
525: /* T Y F 4 2 */
526:
527: export void TyF42(rgTy, isym)
528: pTYR rgTy;
529: long isym;
530: {
531: char *sb, *sbStart;
532: long iss;
533: pTYR ty;
534:
535: SetSym(isym);
536: iss = vsymCur->sbSym;
537: sbStart = SbInCore(iss);
538: sb = strchr(sbStart, ':');
539: if (sb == sbNil) {
540: /* sdb symbol - what you see is what you get */
541: rgTy[0] = *((pTYR) vsymCur);
542: SetSym(isym+1);
543: rgTy[1] = *((pTYR) vsymCur);
544: }
545: else {
546: /* dbx symbol */
547: ty = (pTYR) vsymCur;
548: rgTy[0] = rgTy[1] = *vtyZeros;
549: rgTy->sbVar = SbSafe(sbStart); /* copies up to ':' */
550: rgTy->td.st = ty->td.st;
551: rgTy->valTy = ty->valTy;
552: iss += sb - sbStart;
553: TyFScanDbx(rgTy, iss, isym);
554: SetSym(isym);
555: }
556: } /* TyF42 */
557:
558:
559: /* T Y F F I E L D */
560:
561: local void TyFField(ty, iss)
562: pTYR ty;
563: long iss;
564: {
565: int i, offset, width;
566: char *sbF, *sbS, sbTemp[100];
567:
568: /* somewhere in this symbol is the field info, stuff it in ty */
569: sbF = SbInCore(ty->sbVar);
570: sprintf(sbTemp, "%s:", sbF);
571: sbS = SbInCore(iss);
572: i = IFSbSb(sbS, sbTemp); /* moving window search */
573: if ((i == -1)
574: OR ((sbS[i-1] != ';') AND (!isdigit(sbS[i-1]))) )
575: return; /* caller can detect fact because ty->td.bt == btNil */
576: iss += i + strlen(sbTemp);
577: TyFScanDbx(ty, iss); /* this will build the type info */
578: sbS = 1 + strchr(SbInCore(iss), ',');
579: sscanf(sbS,"%d,%d", &offset, &width);
580: if (((ty->td.bt == btUInt) AND (width != SZINT))
581: OR ((offset % SZCHAR) != 0)
582: OR ((width % SZCHAR) != 0)) {
583: /* this MUST be a bit field */
584: if ((ty->td.bt != btUInt) OR (width > SZINT))
585: Panic("Confused looking at bit field %s @ %ld", sbF, iss);
586: ty->td.width = width;
587: ty->td.bt = btUInt;
588: ty->valTy = offset;
589: }
590: else {
591: ty->td.width = 0;
592: ty->valTy = offset / SZCHAR;
593: }
594: } /* TyFField */
595:
596:
597: /* T Y F L O O K U P */
598:
599: local void TyFLookup(tyStruct, tyField)
600: pTYR tyStruct, tyField;
601: {
602: long iss;
603: pXTYR xty;
604:
605: /* given a structure, see if the field is a member. If so,
606: * return its type stuff. If not, see if we can find a
607: * field by this name and use it. This search is user
608: * selectable.
609: */
610: if ( ((tyStruct->td.bt == btStruct) OR (tyStruct->td.bt == btUnion))
611: AND (tyStruct[1].td.st == stExtend) ) {
612: xty = (pXTYR) (tyStruct+1);
613: iss = xty->issRef; /* this is already absolute because of TyFScanDbx */
614: TyFField(tyField, iss);
615: if (tyField->td.bt != btNil)
616: return;
617: UError("No such field name %s for %s %s",
618: SbInSafe(tyField->sbVar),
619: (tyStruct->td.bt==btStruct) ? "struct" : "union",
620: SbInSafe(iss) );
621: }
622:
623: /* we get here if it wasn't a structure, OR it did not have a field
624: * name as referenced. We will now go looking for something reasonable.
625: * We do not currently do the scan. This means you can't reference
626: * a field name not part of the appropriate struct/union.
627: */
628:
629: } /* TyFLookup */
630:
631:
632: #endif
633:
634: /* ------------------ Back to normal ------------------------ */
635:
636:
637: /* I N I T T Y */
638:
639: export void InitTy()
640: {
641: /* set up standard type descriptors */
642: vtyZeros = &atyZeros;
643: vtyCnChar = &atyCnChar;
644: vtyChar = &atyChar;
645: vtyCnShort = &atyCnShort;
646: vtyShort = &atyShort;
647: vtyCnInt = &atyCnInt;
648: vtyInt = &atyInt;
649: vtyCnLong = &atyCnLong;
650: vtyLong = &atyLong;
651: vtyCnFloat = &atyCnFloat;
652: vtyFloat = &atyFloat;
653: } /* InitTy */
654:
655:
656: /* F I N T F T Y */
657:
658: export FLAGT FIntFTy(ty)
659: pTYR ty;
660: {
661: if (tqPtr == TqFTy(ty, 1))
662: return(true);
663: switch (ty->td.bt) {
664: case btInt:
665: case btUInt:
666: case btUShort:
667: case btShort:
668: case btLong:
669: case btULong:
670: case btChar:
671: case btUChar:
672: case btFArg: /* is this one right??? - kludge */
673: case btEMember:
674: return(true);
675: case btNil:
676: case btFloat:
677: case btDouble:
678: case btEType:
679: case btUnion:
680: case btStruct:
681: return(false);
682: } /* switch */
683: return(false);
684: } /* FIntFTy */
685:
686:
687: /* M A X F T Y T Y */
688:
689: export FLAGT MaxFTyTy(rgTyMax, rgTy1, rgTy2)
690: pTYR rgTyMax, rgTy1, rgTy2;
691: {
692: if (FIntFTy(rgTy1) AND FIntFTy(rgTy2)) {
693: if (CbFTy(rgTy1) >= CbFTy(rgTy2))
694: CopyTy(rgTyMax, rgTy1);
695: else
696: CopyTy(rgTyMax, rgTy2);
697: return(true);
698: } /* if */
699: return(false);
700: } /* MaxFTyTy */
701:
702:
703: /* C O P Y T Y */
704:
705: export void CopyTy(tyDest, tySrc)
706: pTYR tyDest, tySrc;
707: {
708: *tyDest++ = *tySrc++;
709: *tyDest = *tySrc;
710: } /* CopyTy */
711:
712:
713: /* T Y F G L O B A L */
714:
715: export void TyFGlobal(rgTy, sbVar)
716: pTYR rgTy;
717: char *sbVar;
718: {
719:
720: #ifdef SYSIII
721: if (vfnDecl != fnNil) {
722: SetTyNext(vityMac-1, fDoBackward);
723: if (FNextTy(fDoBackward, sbVar, 0, 0, 0, 0)) {
724: CopyTy(rgTy, vtyCur);
725: return;
726: } /* if */
727: } /* if */
728: rgTy[0] = *vtyInt; /* this could easily be WRONG! */
729: strncpy(rgTy[0].sbVar, sbVar, 8);
730: #endif
731: #ifdef BSD41
732: long isymSave;
733: pTYR ty;
734:
735: isymSave = visym;
736: SetSym(isym0);
737: if (FNextSym(stGlobal, stStatic, 0, sbVar, FProcCmp)) {
738: #ifdef BSD42
739: TyF42(rgTy, visym);
740: #else
741: ty = (pTYR) vsymCur;
742: rgTy[0] = *ty;
743: SetSym(visym+1);
744: ty = (pTYR) vsymCur;
745: rgTy[1] = *ty;
746: #endif
747: }
748: else {
749: rgTy[0] = *vtyInt;
750: } /* if */
751: SetSym(isymSave);
752: #endif
753: } /* TyFGlobal */
754:
755:
756: /* T Y F L O C A L */
757:
758: export void TyFLocal(rgTy, sbVar, isym)
759: pTYR rgTy;
760: char *sbVar;
761: long isym;
762: {
763:
764: #ifdef BSD41
765: /* with BSD symbols, the location info for locals is same sym as type */
766: long isymSave;
767: pTYR ty;
768:
769: isymSave = isym;
770: #ifdef BSD42
771: TyF42(rgTy, isym);
772: #else
773: SetSym(isym);
774: ty = (pTYR) vsymCur;
775: rgTy[0] = *ty;
776: SetSym(visym+1);
777: ty = (pTYR) vsymCur;
778: rgTy[1] = *ty;
779: #endif
780: SetSym(isymSave);
781: #else
782: int cb, ln, ity;
783: long isymSave;
784:
785: isymSave = isym;
786: ln = IlnFIsym(isym);
787: if ( (vfnDecl == fnNil)
788: OR ((ity = ItyFSbLn(sbVar, ln)) == ityNil) ) {
789: cb = CbFLocal(isym);
790: SetSym(isymSave);
791: if (cb == 1)
792: CopyTy(rgTy, vtyChar);
793: else if (cb != 4)
794: CopyTy(rgTy, vtyInt);
795: else
796: CopyTy(rgTy, vtyLong);
797: /* this could easily be WRONG! */
798: }
799: else {
800: SetSym(isymSave);
801: SetTy(ity);
802: CopyTy(rgTy, vtyCur);
803: } /* if */
804: rgTy->td.st = stValue;
805: if (vsymCur->type == N_REG)
806: rgTy->td.st = stReg;
807: else if (FHdrCmp(vsbProcHdr, vsymCur->sbSym))
808: rgTy->td.st = stProc;
809: strncpy(rgTy->sbVar, sbVar, cbVarMax-1);
810: rgTy->sbVar[cbVarMax-1] = chNull;
811: #endif
812: } /* TyFLocal */
813:
814:
815: /* T Q F T Y */
816:
817: export int TqFTy(ty, cnt)
818: pTYR ty;
819: int cnt;
820: {
821: #ifdef REGULUS
822: return(tqNil);
823: #else
824: switch (cnt) {
825: case 1:
826: return(ty->td.tq1);
827: case 2:
828: return(ty->td.tq2);
829: case 3:
830: return(ty->td.tq3);
831: case 4:
832: return(ty->td.tq4);
833: case 5:
834: return(ty->td.tq5);
835: case 6:
836: return(ty->td.tq6);
837: } /* switch */
838: #endif
839: } /* TqFTy */
840:
841:
842: /* F A D J T D */
843:
844: export FLAGT FAdjTd(ty, tq)
845: pTYR ty;
846: int tq;
847: {
848: pTDR td;
849: #ifdef REGULUS
850: return(true);
851: #else
852: td = &(ty->td);
853: if (tq != tqNil) {
854: if (td->tq6 != tqNil) {
855: /* all seats are taken */
856: return(false);
857: }
858: else {
859: td->tq6 = td->tq5;
860: td->tq5 = td->tq4;
861: td->tq4 = td->tq3;
862: td->tq3 = td->tq2;
863: td->tq2 = td->tq1;
864: td->tq1 = tq;
865: } /* if */
866: }
867: else {
868: td->tq1 = td->tq2;
869: td->tq2 = td->tq3;
870: td->tq3 = td->tq4;
871: td->tq4 = td->tq5;
872: td->tq5 = td->tq6;
873: td->tq6 = tqNil;
874: } /* if */
875: return(true);
876: #endif
877: } /* FAdjTd */
878:
879:
880: /* C B F T Y */
881:
882: export int CbFTy(ty)
883: pTYR ty;
884: {
885: int tq;
886: pXTYR xty;
887:
888: if (ty == tyNil)
889: return(0);
890:
891: if (ty->td.width != 0)
892: return(-1); /* a bit field */
893:
894: tq = TqFTy(ty, 1);
895: if (tq != tqNil)
896: return(CBPOINT); /* treat it as a pointer */
897:
898: switch (ty->td.bt) {
899: case btNil:
900: return(0);
901: case btInt:
902: case btUInt:
903: return(CBINT);
904: case btUShort:
905: case btShort:
906: return(CBSHORT);
907: case btLong:
908: case btULong:
909: return(CBLONG);
910: case btChar:
911: case btUChar:
912: return(1);
913: case btFloat:
914: return(CBFLOAT);
915: case btDouble:
916: return(CBDOUBLE);
917: case btFArg:
918: case btEType:
919: case btEMember:
920: return(CBINT);
921: case btUnion:
922: case btStruct:
923: /* the following boils down to 'if !BSD41 OR (BSD41 AND !BSD42)' */
924: #ifdef BSD41
925: #ifndef BSD42
926: if (ty[1].td.st != stLeng)
927: return(CBINT);
928: return(ty[1].valTy);
929: #else
930: if (ty[1].td.st != stExtend) {
931: if (ty[1].td.st == stLeng)
932: return(ty[1].valTy);
933: else
934: return(CBINT);
935: }
936: xty = (pXTYR) (ty + 1);
937: return(xty->cb);
938: #endif
939: #else
940: if (ty[1].td.st != stExtend) {
941: if (ty[1].td.st == stLeng)
942: return(ty[1].valTy);
943: else
944: return(CBINT);
945: }
946: xty = (pXTYR) (ty + 1);
947: return(xty->cb);
948: #endif
949: } /* switch */
950: return(0);
951: } /* CbFTy */
952:
953:
954: /* A D R F F I E L D */
955:
956: export long AdrFField(adrLong, tyStruct, tyField)
957: long adrLong;
958: pTYR tyStruct, tyField;
959: {
960: long isymSave;
961: char *sbField;
962: pTYR ty;
963: int issSave;
964:
965: #ifdef BSD41
966: issSave = tyField[0].sbVar; /* wipe everything clean but the name */
967: tyField[0] = *vtyZeros;
968: tyField[1] = *vtyZeros;
969: tyField[0].sbVar = issSave;
970: #ifdef BSD42
971: TyFLookup(tyStruct, tyField); /* does all the 4.2 crap */
972: #endif
973: if (tyField[0].td.bt == btNil) {
974: /* this SUCKS! It is because <4.2 Berkeley compilers have
975: * neanderthal ideas about binding (ie. they don't) field
976: * names to the parent structure.
977: */
978: isymSave = visym;
979: sbField = SbInSafe(tyField->sbVar);
980: SetSym(vrgFd[vifd].isym);
981: if (!FNextSym(stStruct, 0, stSource, sbField, FProcCmp))
982: if (vfPascal)
983: UError("Sorry, Berkeley Pascal does not give me the field names");
984: else
985: UError("No such field name: %s", sbField);
986: ty = (pTYR) vsymCur;
987: tyField[0] = *ty;
988: SetSym(visym+1);
989: ty = (pTYR) vsymCur;
990: tyField[1] = *ty;
991: SetSym(isymSave);
992: if (tyField->td.st != stStruct)
993: UError("'%s' is not a field name", SbInCore(tyField->sbVar));
994: } /* if */
995:
996: if (tyField->td.width != 0) {
997: adrLong += tyField->valTy / SZCHAR; /* set to nearest byte boundary */
998: tyField->valTy %= SZCHAR;
999: }
1000: else {
1001: adrLong += tyField->valTy; /* add its offset to base address */
1002: }
1003: return(adrLong);
1004: #endif
1005: } /* AdrFField */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.