Return to sym.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd / adb

Annotation of 3BSD/cmd/adb/sym.c, revision 1.1

1.1     ! root        1: #
        !             2: /*
        !             3:  *
        !             4:  *     UNIX debugger
        !             5:  *
        !             6:  */
        !             7: 
        !             8: #include "defs.h"
        !             9: SCCSID(@(#)sym.c       2.4);
        !            10: #include "a.out.h"
        !            11: 
        !            12: 
        !            13: MSG            BADFIL;
        !            14: 
        !            15: SYMTAB         symbol;
        !            16: BOOL           localok;
        !            17: ADDR           lastframe;
        !            18: SYMSLAVE               *symvec;
        !            19: ADDR           maxoff;
        !            20: ADDR           maxstor;
        !            21: 
        !            22: /* symbol management */
        !            23: L_INT          symbas;
        !            24: L_INT          symcnt;
        !            25: L_INT          symnum;
        !            26: ADDR           localval;
        !            27: char           symrqd = -1;
        !            28: SYMTAB         symbuf[SYMSIZ];
        !            29: SYMPTR         symnxt;
        !            30: SYMPTR         symend;
        !            31: 
        !            32: 
        !            33: INT            fsym;
        !            34: STRING         errflg;
        !            35: POS            findsym();
        !            36: 
        !            37: 
        !            38: /* symbol table and file handling service routines */
        !            39: 
        !            40: longseek(f, a)
        !            41: L_INT a;
        !            42: {
        !            43: #ifndef EDDT
        !            44:        return(lseek(f,a,0) != -1);
        !            45: #endif
        !            46: }
        !            47: 
        !            48: valpr(v,idsp)
        !            49: {
        !            50:        POS             d;
        !            51:        d = findsym(v,idsp);
        !            52:        IF d < maxoff
        !            53:        THEN    printf("%.8s", symbol.symc);
        !            54:                IF d
        !            55:                THEN    printf(OFFMODE, d);
        !            56:                FI
        !            57:        FI
        !            58: }
        !            59: 
        !            60: localsym(cframe,cargp)
        !            61: ADDR cframe,cargp;
        !            62: {
        !            63: #ifndef EDDT
        !            64:        INT symflg;
        !            65:        WHILE nextsym()
        !            66:                ANDF symbol.symc[0]!='_'
        !            67:                ANDF (symflg=symbol.symf)!=N_FN
        !            68:        DO IF symflg>=N_TEXT ANDF symflg<=(N_BSS|N_EXT)
        !            69:           THEN localval=symbol.symv;
        !            70:                return(TRUE);
        !            71:           ELIF symflg==N_ABS
        !            72:           THEN localval=(symbol.symv<0 ? cframe:cargp)+symbol.symv;
        !            73:                return(TRUE);
        !            74:           FI
        !            75:        OD
        !            76: #endif
        !            77:        return(FALSE);
        !            78: }
        !            79: psymoff(v,type,s)
        !            80: L_INT v; int type; char *s;
        !            81: {
        !            82:        POS             w;
        !            83:        IF (v!=0) THEN w = findsym(v,type); FI
        !            84:        IF v==0 ORF w >= maxoff ORF ((v &~ 0x80000000)<maxoff ANDF w!=0)
        !            85:        THEN printf(LPRMODE,v);
        !            86:        ELSE printf("%.8s", symbol.symc);
        !            87:             IF w THEN printf(OFFMODE,w); FI
        !            88:        FI
        !            89:        printf(s);
        !            90: }
        !            91: 
        !            92: POS
        !            93: findsym(svalue,type)
        !            94: L_INT  svalue;
        !            95: INT    type;
        !            96: {
        !            97:        L_INT           diff, value, symval, offset;
        !            98:        INT             symtyp;
        !            99: #ifndef EDDT
        !           100:        REG SYMSLAVE    *symptr;
        !           101:        SYMSLAVE        *symsav;
        !           102: #else
        !           103:        REG SYMPTR      *symptr;
        !           104:        SYMPTR  *symsav;
        !           105: #endif
        !           106:        value=svalue; diff = 0x7fffffffL; symsav=0;
        !           107:        IF type!=NSYM ANDF (symptr=symvec)
        !           108: #ifndef EDDT
        !           109:        THEN    WHILE diff ANDF (symtyp=symptr->typslave)!=ESYM
        !           110:                DO  IF (type==0 ORF symtyp==type) ANDF symptr->typslave != XSYM
        !           111:                    THEN symval=symptr->valslave;
        !           112:                         IF value-symval<diff
        !           113:                            ANDF value>=symval
        !           114:                         THEN diff = value-symval;
        !           115:                              symsav=symptr;
        !           116:                         FI
        !           117:                    FI
        !           118:                    symptr++;
        !           119:                OD
        !           120:                IF symsav
        !           121:                THEN    offset=leng(symsav-symvec);
        !           122:                        symcnt=symnum-offset;
        !           123:                        longseek(fsym, symbas+offset*SYMTABSIZ);
        !           124:                        read(fsym,&symbol,SYMTABSIZ);
        !           125:                FI
        !           126:        FI
        !           127: #else
        !           128:        THEN    WHILE diff ANDF symptr<symend
        !           129:                DO  IF value-symptr->symv<diff
        !           130:                            ANDF value>=symptr->symv
        !           131:                        THEN diff = value-symptr->symv;
        !           132:                            symsav=symptr;
        !           133:                    FI
        !           134:                    symptr++;
        !           135:                OD
        !           136:                IF symsav THEN cpsym(symsav,&symbol); FI
        !           137:        FI
        !           138: #endif
        !           139:        return(diff);
        !           140: }
        !           141: 
        !           142: #ifdef EDDT
        !           143: cpsym(fm,to) register char *fm,*to;{
        !           144: register int i=12; do *to++= *fm++; while (--i);
        !           145: }
        !           146: #endif
        !           147: 
        !           148: nextsym()
        !           149: {
        !           150:        IF (--symcnt)<0
        !           151:        THEN    return(FALSE);
        !           152: #ifndef EDDT
        !           153:        ELSE    return(longseek(fsym, symbas+(symnum-symcnt)*SYMTABSIZ)!=0 ANDF
        !           154:                        read(fsym,&symbol,SYMTABSIZ)==SYMTABSIZ);
        !           155: #endif
        !           156:        FI
        !           157: }
        !           158: 
        !           159: 
        !           160: 
        !           161: /* sequential search through file */
        !           162: symset()
        !           163: {
        !           164:        symcnt = symnum;
        !           165: #ifndef EDDT
        !           166:        symnxt = symbuf;
        !           167:        IF symrqd
        !           168:        THEN    longseek(fsym, symbas);
        !           169:                symread(); symrqd=FALSE;
        !           170:        ELSE    longseek(fsym, symbas+sizeof symbuf);
        !           171:        FI
        !           172: #else
        !           173:        symnxt=symvec;
        !           174: #endif
        !           175: }
        !           176: 
        !           177: SYMPTR symget()
        !           178: {
        !           179: #ifndef EDDT
        !           180:        REG INT rc;
        !           181:        IF symnxt >= symend
        !           182:        THEN    rc=symread(); symrqd=TRUE;
        !           183:        ELSE    rc=TRUE;
        !           184:        FI
        !           185:        IF --symcnt>0 ANDF rc==0 THEN errflg=BADFIL; FI
        !           186:        return( (symcnt>=0 && rc) ? symnxt++ : 0);
        !           187: #else
        !           188:        IF --symcnt>=0 THEN return(symnxt++); ELSE return(0); FI
        !           189: #endif
        !           190: }
        !           191: 
        !           192: #ifndef EDDT
        !           193: symread()
        !           194: {
        !           195:        INT             symlen;
        !           196: #ifndef vax
        !           197:        short t;        SYMTAB *p;
        !           198: #endif
        !           199: 
        !           200:        symlen=read(fsym,symbuf,sizeof symbuf);
        !           201: #ifndef vax
        !           202:        p=symbuf;
        !           203:        while ((char *)p<(char*)symbuf+symlen) {
        !           204:                t=p->symv.hiword; p->symv.hiword=p->symv.loword; p->symv.loword=t;
        !           205:                p++;
        !           206:        }
        !           207: #endif
        !           208:        IF symlen>=SYMTABSIZ
        !           209:        THEN    symnxt = symbuf;
        !           210:                symend = &symbuf[symlen/SYMTABSIZ];
        !           211:                return(TRUE);
        !           212:        ELSE    return(FALSE);
        !           213:        FI
        !           214: }
        !           215: #endif

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