Return to access.c CVS log

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

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

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