Return to access.c CVS log

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

Annotation of 41BSD/cmd/adb/access.c, revision 1.1.1.1

1.1       root        1: #
                      2: /*
                      3:  *
                      4:  *     UNIX debugger
                      5:  *
                      6:  */
                      7: 
                      8: #include "defs.h"
                      9: static char sccsid[] = "%Z%%M% %I% %G%";
                     10: 
                     11: MSG            ODDADR;
                     12: MSG            BADDAT;
                     13: MSG            BADTXT;
                     14: MAP            txtmap;
                     15: MAP            datmap;
                     16: INT            wtflag;
                     17: STRING         errflg;
                     18: INT            errno;
                     19: 
                     20: INT            pid;
                     21: 
                     22: /* file handling and access routines */
                     23: 
                     24: put(adr,space,value)
                     25: #ifndef EDDT
                     26: L_INT  adr;
                     27: {
                     28:        access(WT,adr,space,value);
                     29: }
                     30: #else
                     31:        L_INT *adr; {*adr=value;}
                     32: #endif
                     33: 
                     34: POS    get(adr, space)
                     35: #ifndef EDDT
                     36: L_INT          adr;
                     37: {
                     38:        return(access(RD,adr,space,0));
                     39: }
                     40: #else
                     41:        L_INT *adr; {return(*adr);}
                     42: #endif
                     43: 
                     44: POS    chkget(n, space)
                     45: L_INT          n;
                     46: {
                     47: #ifndef vax
                     48:        REG INT         w;
                     49: #else
                     50:        REG L_INT       w;
                     51: #endif
                     52: 
                     53:        w = get(n, space);
                     54:        chkerr();
                     55:        return(w);
                     56: }
                     57: 
                     58: POS bchkget(n, space) 
                     59: L_INT  n;
                     60: {
                     61:        return(chkget(n, space) & LOBYTE);
                     62: }
                     63: 
                     64: #ifndef EDDT
                     65: access(mode,adr,space,value)
                     66: L_INT  adr;
                     67: {
                     68:        INT     pmode,rd,file;
                     69:        ADDR    w;
                     70:        rd = mode==RD;
                     71: 
                     72:        IF space == NSP THEN return(0); FI
                     73: 
                     74:        IF pid          /* tracing on? */
                     75:        THEN
                     76: #ifndef vax
                     77:                IF adr&01 ANDF !rd THEN error(ODDADR); FI
                     78: #endif
                     79:             pmode = (space&DSP?(rd?RDUSER:WDUSER):(rd?RIUSER:WIUSER));
                     80:             w = ptrace(pmode, pid, adr, value);
                     81: #ifndef vax
                     82:             IF adr&01
                     83:             THEN w1 = ptrace(pmode, pid, shorten(adr+1), value);
                     84:                  w = (w>>8)&LOBYTE | (w1<<8);
                     85:             FI
                     86: #endif
                     87:             IF errno
                     88:             THEN errflg = (space&DSP ? BADDAT : BADTXT);
                     89:             FI
                     90:             return(w);
                     91:        FI
                     92:        w = 0;
                     93:        IF mode==WT ANDF wtflag==0
                     94:        THEN    error("not in write mode");
                     95:        FI
                     96:        IF !chkmap(&adr,space)
                     97:        THEN return(0);
                     98:        FI
                     99:        file=(space&DSP?datmap.ufd:txtmap.ufd);
                    100:        IF longseek(file,adr)==0 ORF
                    101:           (rd ? read(file,&w,sizeof(w)) : write(file,&value,sizeof(w))) < 1
                    102:        THEN    errflg=(space&DSP?BADDAT:BADTXT);
                    103:        FI
                    104:        return(w);
                    105: 
                    106: }
                    107: #endif
                    108: 
                    109: chkmap(adr,space)
                    110:        REG L_INT       *adr;
                    111:        REG INT         space;
                    112: {
                    113:        REG MAPPTR amap;
                    114:        amap=((space&DSP?&datmap:&txtmap));
                    115:        IF space&STAR ORF !within(*adr,amap->b1,amap->e1)
                    116:        THEN IF within(*adr,amap->b2,amap->e2)
                    117:             THEN *adr += (amap->f2)-(amap->b2);
                    118:             ELSE errflg=(space&DSP?BADDAT:BADTXT); return(0);
                    119:             FI
                    120:        ELSE *adr += (amap->f1)-(amap->b1);
                    121:        FI
                    122:        return(1);
                    123: }
                    124: 
                    125: within(adr,lbd,ubd)
                    126: POS    adr, lbd, ubd;
                    127: {
                    128:        return(adr>=lbd && adr<ubd);
                    129: }
                    130: 
                    131: longseek(f, a)
                    132: L_INT a;
                    133: {
                    134:        return(lseek(f,a,0) != -1);
                    135: }

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