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

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.