![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sym.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 sym.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / cdb |
1.1 root 1: static char sccsid[] = "@(#)sym.c 2.11";
2:
3: #include "cdb.h"
4:
5:
6: #ifdef BSD41
7: /* these are used for caching string space info */
8: export int vcbSbCache;
9: char *vsbCache;
10: char *vsbSs;
11: export int vcbSbFirst, vissLo, vissLim, vissMax;
12: #define cbProcMax 20
13: #define iCacheMax 1000 /* number of symbols in cache */
14:
15: #else
16:
17: export char *vsbProcHdr;
18: export char *vsbLHdr;
19: export char *vsbLnHdr;
20: export char *vsbLeHdr;
21: #define cbProcMax 7
22: #define iCacheMax 256 /* number of symbols in cache */
23: #endif
24:
25: export int vcbVarHdr, vcbProcHdr, vcbLHdr, vcbLeHdr, vcbLnHdr;
26:
27:
28:
29: #ifdef SYSIII
30: #define cbVarHdr 1
31: #define cbProcHdr 2
32: #define cbLHdr 3
33: #define cbLnHdr 4
34: #define cbLeHdr 4
35: #endif
36:
37: #ifdef BSD41
38: #define cbVarHdr 0
39: #define cbProcHdr 0
40: #define cbLHdr 0
41: #define cbLnHdr 0
42: #define cbLeHdr 0
43: #endif
44:
45: export long visym; /* last symbol index used */
46: export long visymGlobal; /* isym of first global */
47: export pSYMR vsymCur; /* the `current' symbol */
48: export char *vsbCorefile, *vsbSymfile;
49: export int vcaseMod; /* has 0 or 040 for case sensitive search */
50: export int vfnSym, vfnCore; /* the symbol file and core file numbers */
51:
52: export long visymMax; /* number of symbols */
53: export long vcbSymFirst; /* byte offset to first symbol */
54: static SYMR vsymCache[iCacheMax]; /* symbol cache */
55: #define cbSymCache sizeof(vsymCache)
56: export long visymLo, visymLim; /* min/max values for what is in cache */
57:
58:
59: /* F S B C M P */
60:
61: export FLAGT FSbCmp(sb1, sb2)
62: char *sb1, *sb2;
63: {
64: while ((*sb1|vcaseMod) == (*sb2|vcaseMod)) {
65: if (*sb1 == chNull)
66: return(true);
67: sb1++;
68: sb2++;
69: } /* while */
70: #ifdef BSD42
71: if ((*sb1 == chNull AND *sb2 == ':')
72: OR (*sb2 == chNull AND *sb1 == ':'))
73: return(true);
74: #endif
75: return(false);
76: } /* FSbCmp */
77:
78:
79: /* F H D R C M P */
80:
81: export FLAGT FHdrCmp(sbHdr, sb2)
82: char *sbHdr, *sb2;
83: {
84: for ( ; (*sbHdr|vcaseMod) == (*sb2|vcaseMod) ; sbHdr++, sb2++)
85: if (*sbHdr == chNull)
86: return(true);
87: return(*sbHdr == chNull);
88: } /* FHdrCmp */
89:
90:
91: /* F P R O C C M P */
92:
93: export FLAGT FProcCmp(sbProc, sbCheck)
94: char *sbProc, *sbCheck;
95: {
96: char *sbSave;
97:
98: /* this is ALMOST like FHdrCmp. If sbProc <= cbProcMax chars in length,
99: * an exact match is required, else it is like FHdrCmp.
100: * This allows us to have '1234567' match '1234567*'
101: * BUT '1234' does NOT match '12345' (or 6 or 7 or *)
102: */
103: sbSave = sbProc;
104: for ( ; (*sbProc|vcaseMod)==(*sbCheck|vcaseMod); sbProc++, sbCheck++) {
105: if (*sbProc == chNull)
106: return(true); /* exact match */
107: } /* for */
108: #ifdef BSD42
109: if ( ((*sbProc == ':') AND (*sbCheck == chNull))
110: OR ((*sbProc == chNull) AND (*sbCheck == ':')) )
111: return(true);
112: #else
113: if ( (*sbProc == chNull)
114: AND (sbProc-sbSave == cbProcMax) )
115: return(true);
116: #endif
117: return(false);
118: } /* FProcCmp */
119:
120:
121: /* S E T C A C H E */
122:
123: local void SetCache(isym)
124: long isym;
125: {
126: int cRead;
127: long offset;
128:
129: if (isym >= visymLo AND isym < visymLim)
130: return; /* it is already in there, somewhere */
131: offset = vcbSymFirst + (isym * cbSYMR);
132: if (lseek(vfnSym, offset, 0) < 0L)
133: Panic("Bad seek in SetCache");
134: cRead = read(vfnSym, vsymCache, cbSymCache);
135: if (cRead < 0)
136: Panic("Bad read in SetCache (cRead: %d)", cRead);
137: visymLo = isym;
138: visymLim = isym + (cRead/cbSYMR);
139: if (visymLim > visymMax)
140: visymLim = visymMax;
141: } /* SetCache */
142:
143:
144: /* S E T S Y M */
145:
146: export void SetSym(isym)
147: long isym;
148: {
149: if (isym < 0 OR isym >= visymMax)
150: Panic("isym out of bounds in SetSym - %d", isym);
151: visym = isym;
152: SetCache(isym);
153: vsymCur = &(vsymCache[isym-visymLo]);
154: } /* SetSym */
155:
156:
157: /* S E T N E X T */
158:
159: export void SetNext(isym)
160: long isym;
161: {
162: if (isym < 0 OR isym >= visymMax)
163: Panic("isym out of bounds in SetNext - %d", isym);
164: visym = isym - 1;
165: if (visym < 0)
166: vsymCur = symNil;
167: else SetSym(visym);
168: } /* SetNext */
169:
170:
171: /* F N E X T S Y M */
172:
173: export FLAGT FNextSym(typHit1, typHit2, typStop, sbHit, Cmp)
174: int typHit1, typHit2, typStop;
175: char *sbHit;
176: FLAGT (* Cmp)();
177: {
178: int typ, i;
179: long isym;
180:
181: isym = visym + 1;
182: while (isym < visymMax) {
183: SetCache(isym);
184: for (i=(isym-visymLo); isym<visymLim; i++, isym++) {
185: vsymCur = &(vsymCache[i]);
186: #ifdef REGULUS
187: typ = vsymCur->type & N_TYPE;
188: #else
189: typ = vsymCur->type & ~N_EXT;
190: #endif
191: if ( ((typ == typHit1)
192: OR (typ == typHit2))
193: AND ((sbHit == sbNil)
194: OR ((*Cmp)(sbHit, SbInCore(vsymCur->sbSym)))) ) {
195: visym = isym;
196: return(true);
197: }
198: else if (typ == typStop) {
199: return(false);
200: } /* if */
201: } /* for */
202: } /* while */
203: return(false); /* off the end of the symbol table */
204: } /* FNextSym */
205:
206:
207: /* I L N F I S Y M */
208:
209: export int IlnFIsym(isym)
210: long isym;
211: {
212: ADRT adr;
213:
214: SetNext(isym);
215: #ifdef SYSIII
216: if (FNextSym(N_TEXT, N_ABS, N_FN, vsbLnHdr, FHdrCmp))
217: return(atoi(vsymCur->sbSym+vcbLnHdr));
218: #endif
219: #ifdef BSD41
220: if (FNextSym(stLine, 0, stProc, sbNil, nil)) {
221: adr = vsymCur->value;
222: isym = visym;
223: /* see if there are any more lines w/ same address, take highest */
224: while (FNextSym(stLine, 0, stProc, sbNil, nil)) {
225: if (vsymCur->value > adr)
226: break;
227: isym = visym;
228: } /* while */
229: SetSym(isym);
230: return(vsymCur->desc);
231: } /* if */
232: #endif
233: return(ilnNil);
234: } /* IlnFIsym */
235:
236:
237: /* F N E X T L O C A L */
238:
239: export FLAGT FNextLocal(fLocal, fParam, sbVar)
240: FLAGT fLocal, fParam;
241: char *sbVar;
242: {
243: int value;
244: long isymSave;
245: char *sbSym;
246: /* set vsymCur to point to next local (or param) and return true,
247: * return false if no more, leaving symbol advanced by one.
248: */
249:
250: isymSave = visym;
251: #ifdef SYSIII
252: while (FNextSym(N_ABS, N_TEXT, 0, "~", FHdrCmp)) {
253: sbSym = SbInCore(vsymCur->sbSym);
254: if (sbSym[1] == '~')
255: break; /* it's the strart of another procedure, bail out */
256: value = vsymCur->value;
257: if ( ((value < 0) AND (!fLocal))
258: OR ((value > 0) AND (!fParam)) )
259: continue; /* wrong value */
260: if (sbVar != sbNil) {
261: if (!FProcCmp(sbSym+vcbVarHdr, sbVar))
262: continue; /* wrong name */
263: }
264: else {
265: /* a non-specific request */
266: if (FHdrCmp(vsbLHdr, sbSym))
267: continue; /* we aren't interested in line numbers */
268: } /* if */
269: return(true);
270: } /* while */
271: #endif
272: #ifdef BSD41
273: while (FNextSym(stLocal, stParam, stProc, sbNil, nil)) {
274: /* we have a param OR a local */
275: if ( ((vsymCur->type == stParam) AND (!fParam))
276: OR ((vsymCur->type == stLocal) AND (!fLocal)) ) {
277: if (fParam AND !fLocal) {
278: SetSym(isymSave+1);
279: return(false); /* NEVER any params after locals */
280: } /* if */
281: continue;
282: } /* if */
283: sbSym = SbInCore(vsymCur->sbSym);
284: if ( (sbVar != sbNil)
285: AND (!FProcCmp(sbSym, sbVar)) )
286: continue; /* wrong name */
287: #ifdef BSD42
288: if (FSbCmp(sbSym, "int"))
289: return(false); /* we ran into the next file */
290: #endif
291: return(true);
292: } /* while */
293: #endif
294: SetSym(isymSave+1); /* we failed, sigh..... */
295: return(false);
296: } /* FNextLocal */
297:
298:
299: /* A D R F E N D O F P R O C */
300:
301: export ADRT AdrFEndOfProc(ipd)
302: int ipd;
303: {
304: long isym;
305:
306: SetNext(vrgPd[ipd].isym);
307: #ifdef SYSIII
308: if (FNextSym(N_TEXT, N_ABS, N_FN, vsbLeHdr, FHdrCmp))
309: return(vsymCur->value);
310: UError("Can't find end of '%s'", vrgPd[ipd].sbProc);
311: #endif
312: #ifdef BSD41
313: SetNext(vrgPd[ipd].isym+1);
314: FNextSym(stProc, 0, stSource, sbNil, nil); /* don't care about true/false */
315: isym = visym;
316: /* now we back up to first stLine we can find - that should be it! */
317: while (true) {
318: SetSym(--isym);
319: if (vsymCur->type == stLine)
320: return(vsymCur->value);
321: } /* while */
322: #endif
323: } /* AdrFEndOfProc */
324:
325:
326: /* A D R F I F D L N */
327:
328: export ADRT AdrFIfdLn(ifd, iln)
329: int ifd, iln;
330: {
331: long isym, isymLast, ilnCur;
332: ADRT adr;
333:
334: SetNext(vrgFd[ifd].isym+1); /* start just AFTER the file symbol */
335:
336: isym = isymLast = isymNil;
337: #ifdef SYSIII
338: while (FNextSym(N_TEXT, N_ABS, N_FN, vsbLnHdr, FHdrCmp)) {
339: if ((ilnCur=atoi(vsymCur->sbSym+vcbLnHdr)) >= iln) {
340: #endif
341: #ifdef BSD41
342: while (FNextSym(stLine, 0, 0, sbNil, nil)) {
343: if ((ilnCur=vsymCur->desc) >= iln) {
344: #endif
345: isym = (ilnCur == iln) ? visym : isymLast;
346: break;
347: } /* if */
348: isymLast = visym;
349: } /* while */
350:
351: if (isym != isymNil) {
352: SetSym(isym);
353: adr = vsymCur->value;
354: }
355: else {
356: adr = adrNil;
357: } /* if */
358: return(adr);
359: } /* AdrFIfdLn */
360:
361:
362: /* I F D L N F A D R */
363:
364: export void IfdLnFAdr(adr, isym, pifd, piln, pslop)
365: ADRT adr;
366: long isym;
367: int *pifd, *piln, *pslop;
368: {
369: int ifd;
370: long isymLast;
371:
372: *pifd = ifd = IfdFAdr(adr);
373: if (ifd == vifdNil)
374: return;
375:
376: /* we now have the file, try to get the line number */
377: if (isym == 0)
378: isym = vrgFd[ifd].isym+1; /* start just AFTER the file symbol */
379: SetNext(isym);
380:
381: isym = isymNil;
382: isymLast = isymNil;
383: #ifndef BSD41
384: while (FNextSym(N_TEXT, N_ABS, N_FN, vsbLnHdr, FHdrCmp)) {
385: if ((vsymCur->value) >= adr) {
386: isym = (vsymCur->value == adr) ? visym : isymLast;
387: break;
388: } /* if */
389: isymLast = visym;
390: } /* while */
391: #else
392: /* we want the HIGHEST line number that applies to a given address */
393: while (FNextSym(stLine, 0, stSource, sbNil, nil)) {
394: if ((vsymCur->value) >= adr) {
395: if ((vsymCur->value > adr)
396: AND (isym != isymNil))
397: break;
398: isym = (vsymCur->value == adr) ? visym : isymLast;
399: } /* if */
400: isymLast = visym;
401: } /* while */
402: #endif
403:
404: *pslop = -1;
405: if (isym != isymNil) {
406: SetSym(isym);
407: #ifdef BSD41
408: *piln = vsymCur->desc;
409: #else
410: *piln = atoi(vsymCur->sbSym+vcbLnHdr);
411: #endif
412: *pslop = adr - vsymCur->value;
413: }
414: else {
415: *piln = ilnNil;
416: } /* if */
417: } /* IfdLnFAdr */
418:
419:
420: #ifdef BSD41
421: /* I N I T S S */
422:
423: export void InitSs()
424: {
425: if (vcbSbCache == 0) {
426: /* we will read the whole thing in. This means that we
427: * aren't really using the cacheing mechanism, but we
428: * leave it for compatibility with systems where we can't
429: * get away with this.
430: */
431: vcbSbCache = vissMax;
432: } /* if */
433: vsbCache = malloc(vcbSbCache);
434: SetIss(0); /* force read first section */
435: } /* InitSs */
436:
437:
438: /* S B I N C O R E */
439:
440: /* neither export NOR local - it is a macro for NON-BSD systems */
441: char * SbInCore(sb)
442: char *sb;
443: {
444: long iss;
445:
446: iss = (long) sb;
447: if (iss == -1)
448: return(sbNil);
449: if (iss & bitHigh)
450: return((char *)(iss & ~bitHigh)); /* a cdb string */
451: /* an a.out string */
452: SetIss(iss);
453: return(vsbSs);
454: } /* SbInCore */
455:
456:
457: /* S E T I S S */
458:
459: export void SetIss(iss)
460: int iss;
461: {
462: long ret, offset, cRead, issSave;
463: char *sbTest;
464:
465: /* printf("SetIss entered with iss=%d\n",iss); */
466: if (iss < 0 OR iss >= vissMax)
467: Panic("Iss out of bounds");
468: if (iss >= vissLo AND iss < vissLim) {
469: /* make sure the WHOLE string is in the cache */
470: issSave = iss;
471: sbTest = vsbCache + (iss - vissLo);
472: while ((iss < vissLim) AND (*sbTest != chNull)) {
473: sbTest++;
474: iss++;
475: } /* while */
476: iss = issSave;
477: if (*sbTest == chNull) {
478: vsbSs = vsbCache + (iss - vissLo);
479: return;
480: }
481: } /* if */
482:
483: /* not in (or not ALL in) the cache - make it the first thing */
484: offset = vcbSbFirst + iss;
485: /* printf("Seeking in symbols file at offset %d\n", offset); */
486: if ((ret=lseek(vfnSym, offset, 0)) < 0L)
487: Panic("Bad seek in SetIss");
488: cRead = read(vfnSym, vsbCache, vcbSbCache);
489: if (cRead < 0)
490: Panic("Bad read in SetIss (cRead: %d)", cRead);
491: vissLo = iss;
492: vissLim = iss + cRead;
493: vsbSs = vsbCache + (iss - vissLo);
494: } /* SetIss */
495: #endif
496:
497:
498: /* I N I T F D P D */
499:
500: export void InitFdPd()
501: {
502: short ipd, i;
503: FLAGT fGotit, fStop;
504: ADRT adr;
505: char *sbTemp, *sbDot;
506: char sbWorking[cbVarMax+5]; /* used for non-bsd41 stuff */
507: pFDR fd;
508: pPDR pd;
509:
510: #ifdef SYSIII
511: /* set up line number names */
512: vsbLHdr = "~_l";
513: vsbLnHdr = "~_lN";
514: vsbLeHdr = "~_lE";
515: vsbProcHdr = "~~";
516: vityMac = 0;
517: #endif
518: vcbVarHdr = cbVarHdr;
519: vcbProcHdr = cbProcHdr;
520: vcbLHdr = cbLHdr;
521: vcbLeHdr = cbLeHdr;
522: vcbLnHdr = cbLnHdr;
523:
524: visymLo = 0;
525: visymLim = -1;
526:
527: /* first we have to see how big file and proc arrays should be */
528: vifdMac = 0;
529: vipdMac = 0;
530: SetNext(isym0);
531: fStop = false; /* goes true when we are processing 'end.o' */
532: #ifdef SYSIII
533: while (FNextSym(N_FN, N_TEXT, 0, sbNil, nil)) {
534: if (vsymCur->type == N_FN) {
535: if (fStop)
536: break;
537: ++vifdMac;
538: }
539: else if (FHdrCmp(vsbProcHdr, SbInCore(vsymCur->sbSym))) {
540: ++vipdMac;
541: if (FSbCmp(SbInCore(vsymCur->sbSym+vcbProcHdr), "_end_"))
542: fStop = true; /* will stop on next file symbol */
543: } /* if */
544: } /* while */
545: #ifndef REGULUS
546: vifdMac -= 1; /* ignore crt0.o */
547: #endif
548: #endif
549: #ifdef BSD41
550: while (FNextSym(stSource, stProc, 0, sbNil, nil)) {
551: if (vsymCur->type == stSource) {
552: /* a file {ning */
553: if (fStop)
554: break;
555: ++vifdMac;
556: }
557: else {
558: /* a procedure */
559: ++vipdMac;
560: if (FSbCmp(SbInCore(vsymCur->sbSym), "_end_"))
561: fStop = true; /* will stop on next file symbol */
562: } /* if */
563: } /* while */
564: #endif
565: if (vipdMac == 0)
566: UError("It appears that NO files have debugging information");
567: if (!fStop)
568: printf("WARNING! 'end.o' was not loaded with this program\n");
569: vifdTemp = vifdMac++;
570: vifd = vifdNil = vifdMac++;
571: vrgFd = (pFDR) malloc(vifdMac * cbFDR); /* allocate the arrays */
572: vcbTot += vifdMac * cbFDR;
573: vrgPd = (pPDR) malloc(vipdMac * cbPDR);
574: vcbTot += vipdMac * cbPDR;
575:
576: /* we scan through again, filling the arrays */
577: fd = vrgFd;
578: pd = vrgPd;
579: ipd = 0;
580: SetNext(isym0);
581: fStop = false;
582: #ifdef SYSIII
583: while (FNextSym(N_FN, N_TEXT, 0, sbNil, nil)) {
584: if (vsymCur->type == N_FN) {
585: #ifndef REGULUS
586: if (FSbCmp(vsymCur->sbSym, "crt0.o"))
587: continue;
588: #endif
589: #endif
590: #ifdef BSD41
591: while (FNextSym(stSource, stProc, 0, sbNil, nil)) {
592: if (vsymCur->type == stSource) {
593: #endif
594: if (fStop)
595: break; /* we have finished processing end.c */
596: fd->adrStart = vsymCur->value;
597: fd->isym = visym;
598: fd->ipd = ipd;
599: fd->ilnMac = ilnNil;
600: fd->rgLn = (uint *) 0;
601: fd->fHasDecl = true; /* will go false if none - IfdFOpen */
602: fd->fWarned = false;
603: #ifdef SYSIII
604: sbTemp = sbWorking;
605: strncpy(sbTemp, vsymCur->sbSym, cbVarMax);
606: sbTemp[cbVarMax] = chNull; /* make sure we have a clean buffer */
607: sbDot = strrchr(sbTemp, '.'); /* find last period */
608: if (sbDot != nil) {
609: sbDot[1] = 'c'; /* somewhat presumptuous, but I write in C */
610: sbDot[2] = 0;
611: }
612: else {
613: /* this will help if name is `01234567' and lost the `.c' */
614: sbTemp[cbVarMax] = '.';
615: sbTemp[cbVarMax+1] = 'c';
616: sbTemp[cbVarMax+2] = 0;
617: } /* if */
618: fd->sbFile = malloc(cbVarMax+5);
619: vcbTot += cbVarMax + 5;
620: #endif
621: #ifdef BSD41
622: #ifdef BSD42
623: sbTemp = SbInCore(SbSafe(SbInCore(vsymCur->sbSym)));
624: #else
625: sbTemp = SbInCore(vsymCur->sbSym);
626: #endif
627: fd->sbFile = malloc(strlen(sbTemp)+2);
628: #endif
629: strcpy(fd->sbFile, sbTemp);
630: fd++;
631: #ifdef SYSIII
632: }
633: else if (FHdrCmp(vsbProcHdr, vsymCur->sbSym)) {
634: #endif
635: #ifdef BSD41
636: }
637: else {
638: #endif
639: adr = vsymCur->value;
640: pd->adrStart = adr;
641: pd->isym = visym;
642: #ifdef SYSIII
643: sbTemp = sbWorking;
644: /* given ~~foo, copy ~foo */
645: strncpy(sbTemp, vsymCur->sbSym+1, cbVarMax-1);
646: /* make it _foo */
647: sbTemp[0] = '_';
648: sbTemp[7] = chNull;
649: pd->sbProc = malloc(cbVarMax+2);
650: vcbTot += cbVarMax + 2;
651: #endif
652: #ifdef BSD41
653: #ifdef BSD42
654: sbTemp = SbInCore(SbSafe(SbInCore(vsymCur->sbSym)));
655: #else
656: sbTemp = SbInCore(vsymCur->sbSym);
657: #endif
658: pd->sbProc = malloc(strlen(sbTemp)+2);
659: #endif
660: strcpy(pd->sbProc, sbTemp);
661: pd++;
662: ipd++;
663: #ifdef BSD41
664: if (FSbCmp(sbTemp, "_end_")) {
665: fStop = true; /* causes us to stop on next file symbol */
666: }
667: #else
668: if (FSbCmp(sbTemp, "__end_"))
669: fStop = true; /* causes us to stop on next file symbol */
670: #endif
671: } /* if */
672: } /* while */
673: visymGlobal = visym;
674: vipd = ipdNil;
675: printf("%d source files, %d procedures\n", vifdMac-2, vipdMac);
676:
677: fd = vrgFd + vifdTemp;
678: fd->adrStart = 0; /* we use vifdTemp for `other' files */
679: fd->sbFile = sbNil;
680: fd->fHasDecl = false;
681: fd->fWarned = true; /* we assume warning here isn't important */
682: fd->isym = isym0;
683: fd->ipd = ipdNil;
684: fd->ilnMac = ilnNil;
685: fd->rgLn = (uint *) 0;
686:
687: fd = vrgFd + vifdNil; /* we use vifdNil as a `catchall' */
688: fd->adrStart = 0;
689: fd->sbFile = "no src file";
690: fd->fHasDecl = false;
691: fd->fWarned = true;
692: fd->isym = isym0;
693: fd->ipd = ipdNil;
694: fd->ilnMac = ilnNil;
695: fd->rgLn = (uint *) 0;
696:
697: #ifdef SYSIII
698: /* the following gives us one more char in procedure name, if it's there */
699: SetNext(visymGlobal);
700: for (i=0; i<vipdMac; i++) {
701: fGotit = false;
702: while (FNextSym(N_TEXT, 0, 0, vrgPd[i].sbProc, FProcCmp)) {
703: if (vsymCur->value == vrgPd[i].adrStart) {
704: fGotit = true;
705: break;
706: } /* if */
707: } /* while */
708: if (!fGotit) {
709: /* try it from the top of globals again */
710: SetNext(visymGlobal);
711: while (FNextSym(N_TEXT, 0, 0, vrgPd[i].sbProc, FProcCmp)) {
712: if (vsymCur->value == vrgPd[i].adrStart) {
713: fGotit = true;
714: break;
715: } /* if */
716: } /* while */
717: } /* if */
718: if (!fGotit) {
719: /* Can't find it, I hope it is a static, else oooops! */
720: strncpy(vrgPd[i].sbProc, vrgPd[i].sbProc+1, 6);
721: vrgPd[i].sbProc[6] = 0;
722: }
723: else {
724: /* we found _foo, copy foo into name area */
725: strncpy(vrgPd[i].sbProc, vsymCur->sbSym+1, 7);
726: vrgPd[i].sbProc[7] = 0;
727: } /* if */
728: } /* for */
729: #endif
730: } /* InitFdPd */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.