Return to as16.c CVS log

Up to [Research Unix] / researchv10no / cmd / PDP11 / 11as

Annotation of researchv10no/cmd/PDP11/11as/as16.c, revision 1.1

1.1     ! root        1: /* a6 -- pdp-11 assembler pass 1 */
        !             2: #include "as1.h"
        !             3: 
        !             4: opline(op)
        !             5: OP op;
        !             6: {
        !             7:        struct expr x;
        !             8:        register int t,len;
        !             9: 
        !            10:        if (ISCHAR(op)) {
        !            11:                if (op.v=='<') goto opl17;
        !            12:        xpr:
        !            13:                expres(op); *dot+=2; return;
        !            14:        }
        !            15:        t=op.xp->typ;
        !            16:        if (t==T_REG || t<T_FLOPD || t>T_JXX) goto xpr;
        !            17:        op=readop();
        !            18:        switch (t) {
        !            19:        case T_REG:
        !            20:        case T_ESTTXT:
        !            21:        case T_ESTDAT:
        !            22:                goto xpr;
        !            23: 
        !            24:        case T_JBR: len=4; goto jxx;
        !            25:        case T_JXX: len=6;
        !            26:          jxx:
        !            27:                x=expres(op);
        !            28:                if (*dotrel==x.typ && ((t=x.val - *dot)<0 && t>=-0376)) len=2;
        !            29:                *dot+=len;
        !            30:                return;
        !            31: 
        !            32:        case T_MUL:
        !            33:        case T_MOVF:
        !            34:        case T_DOUBLE:
        !            35:        case T_FLOPD:
        !            36:        case T_FLOPF:
        !            37:        case T_JSR:
        !            38:                addres(); if (!LAST(',')) {errora(); return;}
        !            39:                op=readop();
        !            40: 
        !            41:        case T_SINGLE:
        !            42:                addres(); *dot+=2; return;
        !            43: 
        !            44:        case T_SOB:
        !            45:                expres(op); if (!LAST(',')) errora();
        !            46:                op=readop();
        !            47: 
        !            48:        case T_BRANCH:
        !            49:        case T_RTS:
        !            50:        case T_SYS:
        !            51:                expres(op); *dot+=2; return;
        !            52: 
        !            53:        case T_BYTE:
        !            54:                for (;;) {
        !            55:                        expres(op); (*dot)++; if (!LAST(',')) break;
        !            56:                        op=readop();
        !            57:                }
        !            58:                return;
        !            59: 
        !            60:        case T_STRING:
        !            61:        opl17:
        !            62:                *dot+=numval; readop(); return;
        !            63: 
        !            64:        case T_EVEN:
        !            65:                (*dot)++; *dot&=~1; return;
        !            66: 
        !            67:        case T_IF:
        !            68:                x=expres(op); if (x.typ!=T_ABS) error('U');
        !            69:                if (x.val==0) ifflg++;
        !            70:        case T_ENDIF:
        !            71:                return;
        !            72: 
        !            73:        case T_GLOBL:
        !            74:                for (;;) {
        !            75:                        if (ISCHAR(op)) break;
        !            76:                        op.xp->typ |= T_EXTERN;
        !            77:                        op=readop(); if (!LAST(',')) break;
        !            78:                        op=readop();
        !            79:                }
        !            80:                return;
        !            81: 
        !            82:        case T__TEXT:
        !            83:        case T__DATA:
        !            84:        case T__BSS:
        !            85:                savdot[*dotrel-T_TEXT] = *dot;
        !            86:                *dot = savdot[t-T__TEXT];
        !            87:                *dotrel = t-T__TEXT+T_TEXT;
        !            88:                return;
        !            89: 
        !            90:        case T_COMM:
        !            91:                if (ISCHAR(op)) {error('x'); return;}
        !            92:                op.xp->typ |= T_EXTERN;
        !            93:                op=readop();
        !            94:                if (!LAST(',')) {error('x'); return;}
        !            95:                expres(readop());
        !            96:                return;
        !            97:        }
        !            98: }
        !            99: 
        !           100: addres()
        !           101: {
        !           102:        register int t;
        !           103:        struct expr x;
        !           104: 
        !           105:        if (LAST('(')) {
        !           106:                x=expres(readop()); chkreg(&x); chkrp();
        !           107:                if (!LAST('+')) return(2);
        !           108:                readop();
        !           109:                return(0);
        !           110:        } else if (LAST('-')) {
        !           111:                readop();
        !           112:                if (!LAST('(')) {
        !           113:                        savop=lastop; lastop.v='-';             /* fall through to end of else-if */
        !           114:                } else {
        !           115:                        x=expres(readop()); chkreg(&x); chkrp();
        !           116:                        return(0);
        !           117:                }
        !           118:        } else if (LAST('$')) {
        !           119:                expres(readop()); *dot+=2; return(0);
        !           120:        } else if (LAST('*')) {
        !           121:                readop(); if (LAST('*')) error('*');
        !           122:                *dot+=(t=addres());
        !           123:                return(t);
        !           124:        }
        !           125:        x=expres(lastop);
        !           126:        if (LAST('(')) {
        !           127:                x=expres(readop()); chkreg(&x); chkrp();
        !           128:                *dot+=2; return(0);
        !           129:        }
        !           130:        if (x.typ==T_REG) {
        !           131:                chkreg(&x); return(0);
        !           132:        }
        !           133:        *dot+=2;
        !           134:        return(0);
        !           135: }
        !           136: 
        !           137: errora()
        !           138: {
        !           139:        error('a');
        !           140: }
        !           141: 
        !           142: chkreg(p)
        !           143: register struct expr *p;
        !           144: {
        !           145:        if (((unsigned)p->val)>7 || (p->typ!=T_ABS && ((unsigned)p->typ)<=T_BSS))
        !           146:                errora();
        !           147: }
        !           148: 
        !           149: errore()
        !           150: {
        !           151:        error('e');
        !           152: }
        !           153: 
        !           154: chkrp()
        !           155: {
        !           156:        if (!LAST(')')) {error(')'); return;}
        !           157:        readop();
        !           158: }

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