Return to 11reloc.c CVS log

Up to [Research Unix] / researchv10dc / cmd / PDP11

Annotation of researchv10dc/cmd/PDP11/11reloc.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * mjm: modified to run on VAX
                      3:  *     added short data type to some variables
                      4:  * relocate command--
                      5:  * 11reloc file [-]octal [ - ]
                      6:  *
                      7:  * relocate object or 11a.out file up in core
                      8:  * by the possibly negated octal number.
                      9:  *
                     10:  * if optional 3rd arg is given,
                     11:  * replace "setd" at start by "nop"
                     12:  */
                     13: 
                     14: short  tbuf[256];      /* mjm */
                     15: short  rbuf[256];      /* mjm */
                     16: int    fin;
                     17: int    fout;
                     18: short  *txtp;          /* mjm */
                     19: short  *relp;          /* mjm */
                     20: long   relloc;
                     21: long   txtloc;
                     22: int    dotdot;
                     23: long   txtsiz;
                     24: unsigned short t1;     /* mjm */
                     25: unsigned short t2;     /* mjm */
                     26: unsigned short t4;     /* mjm */
                     27: unsigned short t7;     /* mjm */
                     28: int    txtw;
                     29: 
                     30: main(argc, argv)
                     31: char *argv[];
                     32: {
                     33:        int sign, c;
                     34: 
                     35:        if (argc<3) {
                     36:        usage:
                     37:                write(1, "11reloc file [-]octal\n", 22);
                     38:                exit(1);
                     39:        }
                     40:        dotdot = 0;
                     41:        if (*argv[2] == '-') {
                     42:                sign = -1;
                     43:                argv[2]++;
                     44:        } else
                     45:                sign = 1;
                     46:        while (*argv[2]) {
                     47:                c = *argv[2]++ - '0';
                     48:                if (c<0 || c>7)
                     49:                        goto usage;
                     50:                dotdot = (dotdot<<3) + c;
                     51:        }
                     52:        dotdot *= sign;
                     53:        if ((fin = open(argv[1], 0)) < 0) {
                     54:                write(1, "File not readable\n", 18);
                     55:                exit(1);
                     56:        }
                     57:        if ((fout = open(argv[1], 1)) < 0) {
                     58:                write(1, "File not writable\n", 18);
                     59:                exit(1);
                     60:        }
                     61:        txtw = read(fin, (char *)tbuf, 512);
                     62:        if (tbuf[0]!=0411 && tbuf[0]!=0410 && tbuf[0]!=0407) {  /* magic */
                     63:                write(1, "Bad format\n", 11);
                     64:                exit(1);
                     65:        }
                     66:        if (tbuf[7] != 0) {             /* relocation? */
                     67:                write (1, "No relocation bits\n", 19);
                     68:                exit(1);
                     69:        }
                     70:        t1 = tbuf[1];
                     71:        t2 = tbuf[2];
                     72:        t4 = tbuf[4];
                     73:        txtloc = 020;
                     74:        if (argc>3 && argv[3][1]=='o') {
                     75:                dotdot += 020;
                     76:                tbuf[0] = 0405; /* old magic */
                     77:                tbuf[1] += tbuf[2];
                     78:                tbuf[2] = 0;
                     79:                tbuf[4] = tbuf[3];
                     80:                tbuf[3] = 0;
                     81:                tbuf[6] = 0240;
                     82:                tbuf[7] = t7 = 0240;
                     83:        }
                     84:        txtsiz = (unsigned)tbuf[1];
                     85:        txtsiz += (unsigned)tbuf[2];
                     86:        relloc = txtloc + txtsiz;
                     87:        txtsiz /= 2;
                     88:        lseek(fin, relloc & ~0777, 0);
                     89:        read(fin, (char *)rbuf, 512);
                     90:        txtp = &tbuf[8];
                     91:        relp = &rbuf[(relloc&0777) >> 1];
                     92:        if (argc>3)             /* nop out "setd" at start */
                     93:                if (tbuf[8] == 0170011)
                     94:                        tbuf[8] = 0240;
                     95:        while(txtsiz--) {
                     96:                switch (*relp & 017) {
                     97: 
                     98:                case 01:        /* pc ref to abs */
                     99:                        *txtp -= dotdot;
                    100:                        break;
                    101: 
                    102:                case 02:        /* ref to text */
                    103:                case 04:                /* ref to data */
                    104:                case 06:                /* ref to bss */
                    105:                        *txtp += dotdot;
                    106: 
                    107:                }
                    108:                advance();
                    109:        }
                    110:        if (txtp != &tbuf[0])
                    111:                write(fout, (char *)&tbuf[0], txtw);
                    112: 
                    113: 
                    114:        txtsiz = t4 / 2;
                    115:        relloc = 020;
                    116:        relloc += t1;
                    117:        relloc += t1;
                    118:        relloc += t2;
                    119:        relloc += t2;
                    120:        lseek(fin, relloc & ~0777, 0);
                    121:        lseek(fout, relloc & ~0777, 0);
                    122:        txtw = read(fin, (char *)tbuf, 512);
                    123:        txtp = &tbuf[(relloc&0777) >> 1] + 4;
                    124:        while((txtsiz -= 6) > 0) {
                    125:                switch(*txtp & 77) {
                    126: 
                    127:                case 2:
                    128:                case 3:
                    129:                case 4:
                    130:                        *(txtp + 1) += dotdot;
                    131:                }
                    132:                adv6();
                    133:        }
                    134:        if(txtp != &tbuf[0])
                    135:                write(fout, (char *)&tbuf[0], txtw);
                    136:        exit(0);
                    137: }
                    138: 
                    139: advance()
                    140: {
                    141:        
                    142:        relp++;
                    143:        relloc += 2;
                    144:        if (relp == &rbuf[256]) {
                    145:                lseek(fin, relloc, 0);
                    146:                read(fin, (char *)&rbuf[0], 512);
                    147:                relp = &rbuf[0];
                    148:        }
                    149:        txtp++;
                    150:        txtloc += 2;
                    151:        if (txtp >= &tbuf[256]) {
                    152:                write(fout, (char *)&tbuf[0], txtw);
                    153:                lseek(fin, txtloc, 0);
                    154:                txtw = read(fin, (char *)&tbuf[0], 512);
                    155:                txtp = &tbuf[0];
                    156:        }
                    157: }
                    158: 
                    159: adv6()
                    160: {
                    161:        txtp += 6;
                    162:        if(txtp >= &tbuf[256]) {
                    163:                write(fout, (char *)tbuf, txtw);
                    164:                txtw = read(fin, (char *)tbuf, 512);
                    165:                txtp -= 256;
                    166:        }
                    167: }

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