Return to addr.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin / as / i8086

Annotation of coherent/d/bin/as/i8086/addr.c, revision 1.1

1.1     ! root        1: #include "asm.h"
        !             2: 
        !             3: /*
        !             4:  * Address mode table.
        !             5:  * This table is indexed by the number
        !             6:  * that gets put in the r/m field,
        !             7:  * and holds a word containing a bit for
        !             8:  * each index register.
        !             9:  */
        !            10: 
        !            11: int    amodes[] = {
        !            12:        (1<<reg(BX)) + (1<<reg(SI)),
        !            13:        (1<<reg(BX)) + (1<<reg(DI)),
        !            14:        (1<<reg(BP)) + (1<<reg(SI)),
        !            15:        (1<<reg(BP)) + (1<<reg(DI)),
        !            16:        (1<<reg(SI)),
        !            17:        (1<<reg(DI)),
        !            18:        (1<<reg(BP)),
        !            19:        (1<<reg(BX))
        !            20: };
        !            21: 
        !            22: char   segovr[] = {
        !            23:        0x26,
        !            24:        0x2E,
        !            25:        0x36,
        !            26:        0x3E
        !            27: };
        !            28: 
        !            29: /*
        !            30:  * Read an address.
        !            31:  * Return the addressing mode.
        !            32:  */
        !            33: addr(esp)
        !            34: register struct expr *esp;
        !            35: {
        !            36:        register c;
        !            37: 
        !            38:        if ((c = getnb()) == '$') {
        !            39:                expr(esp, 0);
        !            40:                esp->e_mode = IM;
        !            41:                return (IM);
        !            42:        }
        !            43:        if (c == '(') {
        !            44:                addrx(esp);
        !            45:                esp->e_type = E_ACON;
        !            46:                esp->e_addr = 0;
        !            47:                return (esp->e_mode & MMASK);
        !            48:        }
        !            49:        unget(c);
        !            50:        expr(esp, 0);
        !            51:        if (esp->e_type == E_AREG) {
        !            52:                esp->e_mode = esp->e_addr;
        !            53:                if ((esp->e_mode & MMASK) == SEGR)
        !            54:                        if ((c = getnb()) == ':') {     /* segment override */
        !            55:                                outab(segovr[reg(esp->e_addr)]);
        !            56:                                addr(esp);
        !            57:                        } else
        !            58:                                unget(c);
        !            59:                return (esp->e_mode & MMASK);
        !            60:        }
        !            61:        if ((c = getnb()) == '(') {
        !            62:                addrx(esp);
        !            63:                if (esp->e_mode==IDX || esp->e_mode==ICL)
        !            64:                        aerr("invalid index register");
        !            65:                return (esp->e_mode & MMASK);
        !            66:        }
        !            67:        unget(c);
        !            68:        esp->e_mode = DIR;
        !            69:        return (DIR);
        !            70: }
        !            71: 
        !            72: /*
        !            73:  * Read in index register field
        !            74:  * of an address. The leading `(' has already
        !            75:  * been read. Set the mode into the `e_mode'
        !            76:  * field of the expression structure.
        !            77:  */
        !            78: addrx(esp)
        !            79: struct expr *esp;
        !            80: {
        !            81:        register struct sym *sp;
        !            82:        register c, i;
        !            83:        int mask, mode;
        !            84:        char id[NCPLN];
        !            85: 
        !            86:        mode = 0;
        !            87:        do {
        !            88:                getid(id, -1);
        !            89:                if ((sp=lookup(id, 0))==NULL || sp->s_type!=E_AREG)
        !            90:                        aerr("index by non-register");
        !            91:                else {
        !            92:                        mask = 01 << reg(sp->s_addr);
        !            93:                        if ((mode&mask) != 0)
        !            94:                                aerr("invalid index register");
        !            95:                        mode |= mask;
        !            96:                }
        !            97:        } while ((c = getnb()) == ',');
        !            98:        if (c != ')')
        !            99:                qerr("missing ')'");
        !           100:        if (mode == (01<<reg(CL))) {
        !           101:                esp->e_mode = ICL;
        !           102:                return;
        !           103:        }
        !           104:        if (mode == (01<<reg(DX))) {
        !           105:                esp->e_mode = IDX;
        !           106:                return;
        !           107:        }
        !           108:        for (i=0; i<8; ++i) {
        !           109:                if (mode == amodes[i]) {
        !           110:                        esp->e_mode = X | i;
        !           111:                        return;
        !           112:                }
        !           113:        }
        !           114:        aerr("invalid index");
        !           115:        esp->e_mode = D;
        !           116: }

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