Return to addr.c,v CVS log

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

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

1.1     ! root        1: head     1.2;
        !             2: access   ;
        !             3: symbols  ;
        !             4: locks    bin:1.2;
        !             5: comment  @ * @;
        !             6: 
        !             7: 
        !             8: 1.2
        !             9: date     91.02.06.20.42.57;  author bin;  state Exp;
        !            10: branches ;
        !            11: next   1.1;
        !            12: 
        !            13: 1.1
        !            14: date     91.02.06.20.42.47;  author bin;  state Exp;
        !            15: branches ;
        !            16: next   ;
        !            17: 
        !            18: 
        !            19: desc
        !            20: @steve 2/6/91
        !            21: Initial MWC RCS revision.
        !            22: @
        !            23: 
        !            24: 
        !            25: 1.2
        !            26: log
        !            27: @steve 2/6/91
        !            28: Descriptive error messages.
        !            29: @
        !            30: text
        !            31: @#include "asm.h"
        !            32: 
        !            33: /*
        !            34:  * Address mode table.
        !            35:  * This table is indexed by the number
        !            36:  * that gets put in the r/m field,
        !            37:  * and holds a word containing a bit for
        !            38:  * each index register.
        !            39:  */
        !            40: 
        !            41: int    amodes[] = {
        !            42:        (1<<reg(BX)) + (1<<reg(SI)),
        !            43:        (1<<reg(BX)) + (1<<reg(DI)),
        !            44:        (1<<reg(BP)) + (1<<reg(SI)),
        !            45:        (1<<reg(BP)) + (1<<reg(DI)),
        !            46:        (1<<reg(SI)),
        !            47:        (1<<reg(DI)),
        !            48:        (1<<reg(BP)),
        !            49:        (1<<reg(BX))
        !            50: };
        !            51: 
        !            52: char   segovr[] = {
        !            53:        0x26,
        !            54:        0x2E,
        !            55:        0x36,
        !            56:        0x3E
        !            57: };
        !            58: 
        !            59: /*
        !            60:  * Read an address.
        !            61:  * Return the addressing mode.
        !            62:  */
        !            63: addr(esp)
        !            64: register struct expr *esp;
        !            65: {
        !            66:        register c;
        !            67: 
        !            68:        if ((c = getnb()) == '$') {
        !            69:                expr(esp, 0);
        !            70:                esp->e_mode = IM;
        !            71:                return (IM);
        !            72:        }
        !            73:        if (c == '(') {
        !            74:                addrx(esp);
        !            75:                esp->e_type = E_ACON;
        !            76:                esp->e_addr = 0;
        !            77:                return (esp->e_mode & MMASK);
        !            78:        }
        !            79:        unget(c);
        !            80:        expr(esp, 0);
        !            81:        if (esp->e_type == E_AREG) {
        !            82:                esp->e_mode = esp->e_addr;
        !            83:                if ((esp->e_mode & MMASK) == SEGR)
        !            84:                        if ((c = getnb()) == ':') {     /* segment override */
        !            85:                                outab(segovr[reg(esp->e_addr)]);
        !            86:                                addr(esp);
        !            87:                        } else
        !            88:                                unget(c);
        !            89:                return (esp->e_mode & MMASK);
        !            90:        }
        !            91:        if ((c = getnb()) == '(') {
        !            92:                addrx(esp);
        !            93:                if (esp->e_mode==IDX || esp->e_mode==ICL)
        !            94:                        aerr("invalid index register");
        !            95:                return (esp->e_mode & MMASK);
        !            96:        }
        !            97:        unget(c);
        !            98:        esp->e_mode = DIR;
        !            99:        return (DIR);
        !           100: }
        !           101: 
        !           102: /*
        !           103:  * Read in index register field
        !           104:  * of an address. The leading `(' has already
        !           105:  * been read. Set the mode into the `e_mode'
        !           106:  * field of the expression structure.
        !           107:  */
        !           108: addrx(esp)
        !           109: struct expr *esp;
        !           110: {
        !           111:        register struct sym *sp;
        !           112:        register c, i;
        !           113:        int mask, mode;
        !           114:        char id[NCPLN];
        !           115: 
        !           116:        mode = 0;
        !           117:        do {
        !           118:                getid(id, -1);
        !           119:                if ((sp=lookup(id, 0))==NULL || sp->s_type!=E_AREG)
        !           120:                        aerr("index by non-register");
        !           121:                else {
        !           122:                        mask = 01 << reg(sp->s_addr);
        !           123:                        if ((mode&mask) != 0)
        !           124:                                aerr("invalid index register");
        !           125:                        mode |= mask;
        !           126:                }
        !           127:        } while ((c = getnb()) == ',');
        !           128:        if (c != ')')
        !           129:                qerr("missing ')'");
        !           130:        if (mode == (01<<reg(CL))) {
        !           131:                esp->e_mode = ICL;
        !           132:                return;
        !           133:        }
        !           134:        if (mode == (01<<reg(DX))) {
        !           135:                esp->e_mode = IDX;
        !           136:                return;
        !           137:        }
        !           138:        for (i=0; i<8; ++i) {
        !           139:                if (mode == amodes[i]) {
        !           140:                        esp->e_mode = X | i;
        !           141:                        return;
        !           142:                }
        !           143:        }
        !           144:        aerr("invalid index");
        !           145:        esp->e_mode = D;
        !           146: }
        !           147: @
        !           148: 
        !           149: 
        !           150: 1.1
        !           151: log
        !           152: @Initial revision
        !           153: @
        !           154: text
        !           155: @d64 1
        !           156: a64 1
        !           157:                        aerr();
        !           158: d90 1
        !           159: a90 1
        !           160:                        aerr();
        !           161: d94 1
        !           162: a94 1
        !           163:                                aerr();
        !           164: d99 1
        !           165: a99 1
        !           166:                qerr();
        !           167: d114 1
        !           168: a114 1
        !           169:        aerr();
        !           170: @

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