Return to tables.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / usr.bin / cdb / transBsd

Annotation of cci/usr/src/usr.bin/cdb/transBsd/tables.c, revision 1.1

1.1     ! root        1: /* $Header: tables.c,v 1.1 86/03/24 16:19:23 rcs Exp $ */
        !             2: /* (C) Copyright 1985 Third Eye Software, Inc. - All Rights Reserved */
        !             3: 
        !             4: #include "tes42.h"
        !             5: 
        !             6: #include <stab.h>
        !             7: 
        !             8: 
        !             9: /* E N D   P R O C */
        !            10: 
        !            11: export void EndProc(adr)
        !            12: ADRT   adr;
        !            13: {
        !            14:     pSYMR      sym;
        !            15: 
        !            16:     sym = SymFInsert();
        !            17:     sym->st = stEnd;
        !            18:     sym->sc = scText;
        !            19:     sym->index = IsymFSym(vsymProc);
        !            20:     sym->value = adr;
        !            21:     ChangeAux(vsymProc->index, visym+1);
        !            22:     vsymProc = symNil;
        !            23: 
        !            24:     sym = SymFIsym(visym-1);   /* check previous guy, too */
        !            25:     if (sym->st == stEnd)
        !            26:        sym->value = adr;
        !            27: } /* EndProc */
        !            28: 
        !            29: 
        !            30: /* D O   P R O C  */
        !            31: 
        !            32: export void DoProc(nlist)
        !            33: pNLISTR        nlist;
        !            34: {
        !            35:     if (vsymProc != symNil)
        !            36:        EndProc(nlist->n_value);
        !            37: 
        !            38:     vsymProc = SymFInsert();
        !            39:     vsymProc->st = stProc;
        !            40:     vsymProc->index = AddAux(-1);
        !            41:     ProcInsert(IsymFSym(vsymProc), nlist->n_value, vilineMac);
        !            42:     vcLinesInProc = 0;
        !            43: } /* DoProc */
        !            44: 
        !            45: 
        !            46: /* P S B H   F   H A S H   S B */
        !            47: 
        !            48: local pSBHR PsbhFHashSb(sb)
        !            49: register char  *sb;
        !            50: {
        !            51:     register int       sum = 0;
        !            52: 
        !            53:     while (sb && *sb)
        !            54:        sum += *sb++;
        !            55: 
        !            56:     return(&vpsbhBucket [sum % hashMod]);
        !            57: } /* PsbhFHashSb */
        !            58: 
        !            59: 
        !            60: /* I S S   F   S B   I N S E R T */
        !            61: 
        !            62: export long IssFSbInsert(sb)
        !            63: register char  *sb;
        !            64: {
        !            65:     register pSBHR     psbh;
        !            66:     register pSBHR     psbhPrev;
        !            67:     register char      *sbT;
        !            68:     register int       sum;
        !            69: 
        !            70:     sum = 0;
        !            71:     if (sb != 0) {
        !            72:        sbT = sb;
        !            73:        while (*sbT)
        !            74:            sum += *sbT++;
        !            75:     } /* if */
        !            76:     psbh = vpsbhBucket + (sum % hashMod);
        !            77: 
        !            78:     while (psbh) {
        !            79:        if ( (psbh->sb != 0)
        !            80:           && (!strcmp(sb, psbh->sb)) ) {
        !            81:            return(psbh->iss);
        !            82:        } /* if */
        !            83:        psbhPrev = psbh;
        !            84:        psbh = psbh->psbh;
        !            85:     } /* while */
        !            86: 
        !            87:     psbh = psbhPrev;
        !            88:     psbh->psbh = (pSBHR) malloc (cbSBHR);
        !            89:     psbh = psbh->psbh;
        !            90:     sbT = psbh->sb = vsbMax;
        !            91:     psbh->iss = vissMac;
        !            92:     while (*(sbT++) = *(sb++))
        !            93:        ;
        !            94: 
        !            95:     vsbMax = sbT;
        !            96:     vissMac = vsbMax - vsbNewStr;
        !            97:     if (vissMac > vissMax)
        !            98:        panic("Ran out of string space - use scaling factor");
        !            99: 
        !           100:     vissMac++;
        !           101:     *(vsbMax++) = '\0';
        !           102:     psbh->psbh = (pSBHR) 0;
        !           103: 
        !           104:     return (psbh->iss);
        !           105: } /* IssFSbInsert */
        !           106: 
        !           107: 
        !           108: /* D O   L I N E */
        !           109: 
        !           110: export void DoLine(nlist)
        !           111: pNLISTR        nlist;
        !           112: {
        !           113:     pLINER     line;
        !           114:     static ADRT        adrSecondLine;
        !           115: 
        !           116:     if (vcLinesInProc == 1) {
        !           117:        /* If there is more than one line in a proc, we ignore the first.
        !           118:         * This is correct for all cases except:
        !           119:         *      foo() {int x = 1;
        !           120:         *         .... etc.
        !           121:         *
        !           122:         * Which is brain damaged and life is tough, so there.
        !           123:         */
        !           124:        vilineMac--;
        !           125:        adrSecondLine = nlist->n_value;
        !           126:     } else if ((vcLinesInProc >= 2) && (nlist->n_value == adrSecondLine)) {
        !           127:        /* throw away previous line */
        !           128:        vilineMac--;
        !           129:     } /* if */
        !           130: 
        !           131:     if (vilineMac >= vilineMax)
        !           132:        panic ("line table overflow");
        !           133:     viline = vilineMac++;
        !           134: 
        !           135:     line= vrgLine + viline;
        !           136:     line->iln= nlist->n_desc;
        !           137:     line->dadr= nlist->n_value - vrgPd[vipd].adr;
        !           138:     vdot = nlist->n_value;
        !           139:     vcLinesInProc++;
        !           140: } /* DoLine */
        !           141: 
        !           142: 
        !           143: /* E N D   F I L E */
        !           144: 
        !           145: export void EndFile(adr)
        !           146: ADRT   adr;
        !           147: {
        !           148:     register pSYMR     sym;
        !           149: 
        !           150:     if (vsymProc != symNil)
        !           151:        EndProc(adr);
        !           152: 
        !           153:     vrgFd[vifd].ilnMac = vrgLine[viline].iln; /* kludge? */
        !           154:     sym = SymFInsert();
        !           155:     sym->st = stEnd;
        !           156:     sym->sc = scText;
        !           157:     sym->index = IsymFSym (vsymFile);
        !           158:     vsymFile->index = IsymFSym(sym) + 1;       /* forward link */
        !           159:     sym->value = (vdot == vsymFile->value) ? adr : vdot;
        !           160: } /* EndFile */
        !           161: 
        !           162: 
        !           163: /* D O   F I L E */
        !           164: 
        !           165: export void DoFile (nlist, sbName)
        !           166: pNLISTR        nlist;
        !           167: char           *sbName;
        !           168: {
        !           169:     register pFDR      fd;
        !           170:     register pSYMR     sym;
        !           171:     ADRT       adr;
        !           172:     int                cb;
        !           173: 
        !           174:     if (vsymFile != symNil)
        !           175:        EndFile(nlist->n_value);
        !           176: 
        !           177:     adr = (nlist == nlistNil) ? -1L : nlist->n_value;
        !           178: 
        !           179:    /* The weird chack for ending character of the filename
        !           180:     * is to see if a file of pure data came before us.
        !           181:     */
        !           182:     if ((vifd > 0)
        !           183:        && (sbName[strlen(sbName)-1] != 'o')
        !           184:        && (vrgFd[vifd].adr == adr)) {
        !           185:        /* this is the TRUE source file after Loader freebie symbol */
        !           186:        fd= vrgFd  + vifd;
        !           187:        visymMac = IsymFSym(vsymFile);  /* one more time! */
        !           188:     } else {
        !           189:        if (vifdMac >= vifdMax)
        !           190:            panic ("file table overflow");
        !           191:        vifd = vifdMac++;
        !           192:        fd= vrgFd + vifd;
        !           193:     } /* if */
        !           194: 
        !           195:     cb = strlen(sbName);
        !           196:     fd->iss = IssFSbInsert(sbName);
        !           197:     fd->adr = adr;
        !           198:     fd->isym = visymMac;
        !           199:     fd->iline = vilineMac;
        !           200: 
        !           201:     vsymFile = sym = SymFInsert();
        !           202:     sym->iss = fd->iss;
        !           203:     sym->st = stFile;
        !           204:     sym->sc = scText;
        !           205:     vdot = sym->value = adr;
        !           206: 
        !           207:     /* reinit mapping array */
        !           208:     ZeroBlock(&vrgTesF42 [tesF42Low],
        !           209:        ((vites42Max + 1) - tesF42Low) * sizeof(int) );
        !           210:     vites42Max = tesF42Low;
        !           211: } /* DoFile */
        !           212: 
        !           213: 
        !           214: /* P R O C   I N S E R T */
        !           215: 
        !           216: export void ProcInsert(isym, adr, iline)
        !           217: register int   isym;
        !           218: register long  adr;
        !           219: register int   iline;
        !           220: {
        !           221:     register pPDR      pd, pd2;
        !           222: 
        !           223:     if (vipdMac >= vipdMax)
        !           224:        panic("proc table overflow");
        !           225: 
        !           226:     vipd = vipdMac++;
        !           227: 
        !           228:     if ((vipd > 0) && (adr < vrgPd [vipd - 1].adr)) {
        !           229:        /* we need to INSERT - not Append */
        !           230: 
        !           231:        /* find the proc we come AFTER */
        !           232:        for (pd = vrgPd + vipd - 1; (pd >= vrgPd) && (pd->adr > adr); pd--)
        !           233:                ;
        !           234:        /* move everything below it DOWN one */
        !           235:        for (pd2 = vrgPd + vipd - 1; pd2 > pd; pd2--)
        !           236:            pd2[1] = *pd2;
        !           237:        pd++;   /* point at new empty slot */
        !           238:     } else {
        !           239:        pd = vrgPd + vipd;
        !           240:     } /* if */
        !           241: 
        !           242:     pd->isym = isym;
        !           243:     pd->adr = adr;
        !           244:     pd->iline = iline;
        !           245: } /* ProcInsert */
        !           246: 
        !           247: strcmp(sb1, sb2)
        !           248: char *sb1, *sb2;
        !           249: {
        !           250:     if (sb1 == 0 || sb2 == 0)
        !           251:        return(1);
        !           252:     while (*sb1 == *sb2) {
        !           253:        if (*sb1 == '\0')
        !           254:            return(0);
        !           255:        sb1++;
        !           256:        sb2++;
        !           257:     } /* while */
        !           258:     return(1);
        !           259: } /* strcmp */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.