Return to sno4.c CVS log

Up to [Research Unix] / researchv10no / cmd / sno

Annotation of researchv10no/cmd/sno/sno4.c, revision 1.1

1.1     ! root        1: /*     @(#)sno4.c      1.1     */
        !             2: #include "sno.h"
        !             3: /*
        !             4:  * sno4
        !             5:  */
        !             6: 
        !             7: 
        !             8: struct node *
        !             9: and (ptr)
        !            10:        struct node *ptr;
        !            11: {
        !            12:        register struct node *a, *p;
        !            13: 
        !            14:        p = ptr;
        !            15:        a = p->p1;
        !            16:        if (p->typ == 0) {
        !            17:                switch (a->typ) {
        !            18:                case0:
        !            19:                case 0:
        !            20:                        a->typ = 1;
        !            21:                case 1:
        !            22:                        goto l1;
        !            23:                case 3:
        !            24:                        fflush (stdout);
        !            25:                        return (syspit());
        !            26:                case 5:
        !            27:                        a = a->p2->p1;
        !            28:                        goto l1;
        !            29:                case 6:
        !            30:                        return (binstr (nfree()));
        !            31:                }
        !            32:                writes ("attempt to take an illegal value");
        !            33:                goto case0;
        !            34:        l1:
        !            35:                a = copy (a->p2);
        !            36:        }
        !            37:        return (a);
        !            38: }
        !            39: 
        !            40: struct node *
        !            41: eval (e, t)
        !            42:        struct node *e;
        !            43: {
        !            44:        struct node *list, *a2, *a3, *a4, *a3base;
        !            45:        register struct node *a1, *stack, *op;
        !            46: 
        !            47:        if (rfail == 1)
        !            48:                return (0);
        !            49:        stack = 0;
        !            50:        list = e;
        !            51:        goto l1;
        !            52: advanc:
        !            53:        list = list->p1;
        !            54: l1:
        !            55:        switch (list->typ) {
        !            56:                default:
        !            57:                case 0:
        !            58:                if (t == 1) {
        !            59:                        a1 = and (stack);
        !            60:                        goto e1;
        !            61:                }
        !            62:                if (stack->typ == 1)
        !            63:                        writes ("attempt to store in a value");
        !            64:                a1 = stack->p1;
        !            65:        e1:
        !            66:                stack = pop (stack);
        !            67:                if (stack)
        !            68:                        writes ("phase error");
        !            69:                return (a1);
        !            70:        case 12:
        !            71:                a1 = and (stack);
        !            72:                stack->p1 = look (a1);
        !            73:                delete (a1);
        !            74:                stack->typ = 0;
        !            75:                goto advanc;
        !            76:        case 13:
        !            77:                if (stack->typ)
        !            78:                        writes ("illegal function");
        !            79:                a1 = stack->p1;
        !            80:                if (a1->typ!=5)
        !            81:                        writes ("illegal function");
        !            82:                a1 = a1->p2;
        !            83:                op = a1->p1;
        !            84:                a3base = a3 = salloc();
        !            85:                a3->p2 = op->p2;
        !            86:                op->p2 = 0;
        !            87:                a1 = a1->p2;
        !            88:                a2 = list->p2;
        !            89:        f1:
        !            90:                if (a1!=0 && a2!=0)
        !            91:                        goto f2;
        !            92:                if (a1!=a2)
        !            93:                        writes ("parameters do not match");
        !            94:                op = op->p1;
        !            95:                goto f3;
        !            96:        f2:
        !            97:                a3->p1 = a4 = salloc();
        !            98:                a3 = a4;
        !            99:                a3->p2 = and (a1);
        !           100:                assign (a1->p1, eval (a2->p2, 1));/* recursive */
        !           101:                a1 = a1->p2;
        !           102:                a2 = a2->p1;
        !           103:                goto f1;
        !           104:        f3:
        !           105:                op = execute (op); /* recursive */
        !           106:                if (op)
        !           107:                        goto f3;
        !           108:                a1 = stack->p1->p2;
        !           109:                op = a1->p1;
        !           110:                a3 = a3base;
        !           111:                stack->p1 = op->p2;
        !           112:                stack->typ = 1;
        !           113:                op->p2 = a3->p2;
        !           114:        f4:
        !           115:                a4 = a3->p1;
        !           116:                sfree (a3);
        !           117:                a3 = a4;
        !           118:                a1 = a1->p2;
        !           119:                if (a1 == 0)
        !           120:                        goto advanc;
        !           121:                assign (a1->p1, a3->p2);
        !           122:                goto f4;
        !           123:        case 11:
        !           124:        case 10:
        !           125:        case 9:
        !           126:        case 8:
        !           127:        case 7:
        !           128:                a1 = and (stack);
        !           129:                stack = pop (stack);
        !           130:                a2 = and (stack);
        !           131:                a3 = doop (list->typ, a2, a1);
        !           132:                delete (a1);
        !           133:                delete (a2);
        !           134:                stack->p1 = a3;
        !           135:                stack->typ = 1;
        !           136:                goto advanc;
        !           137:        case 15:
        !           138:                a1 = copy (list->p2);
        !           139:                a2 = (struct node *) 1;
        !           140:                goto l3;
        !           141:        case 14:
        !           142:                a1 = list->p2;
        !           143:                a2 = 0;
        !           144:        l3:
        !           145:                stack = push (stack);
        !           146:                stack->p1 = a1;
        !           147:                stack->typ = (int) a2;
        !           148:                goto advanc;
        !           149:        }
        !           150: }
        !           151: 
        !           152: struct node *
        !           153: doop (op, arg1, arg2)
        !           154:        struct node *arg1, *arg2;
        !           155: {
        !           156:        register struct node *a1, *a2;
        !           157: 
        !           158:        a1 = arg1;
        !           159:        a2 = arg2;
        !           160:        switch (op) {
        !           161: 
        !           162:        case 11:
        !           163:                return (div (a1, a2));
        !           164:        case 10:
        !           165:                return (mult (a1, a2));
        !           166:        case 8:
        !           167:                return (add (a1, a2));
        !           168:        case 9:
        !           169:                return (sub (a1, a2));
        !           170:        case 7:
        !           171:                return (cat (a1, a2));
        !           172:        }
        !           173:        return (0);
        !           174: }
        !           175: 
        !           176: struct node *
        !           177: execute (e)
        !           178:        struct node *e;
        !           179: {
        !           180:        register struct node *r, *b, *c;
        !           181:        struct node *m, *ca, *d, *a;
        !           182: 
        !           183:        r = e->p2;
        !           184:        lc = e->ch;
        !           185:        switch (e->typ) {
        !           186:        case 0: /*  r g */
        !           187:                a = r->p1;
        !           188:                delete (eval (r->p2, 1));
        !           189:                goto xsuc;
        !           190:        case 1: /*  r m g */
        !           191:                m = r->p1;
        !           192:                a = m->p1;
        !           193:                b = eval (r->p2, 1);
        !           194:                c = search (m, b);
        !           195:                delete (b);
        !           196:                if (c == 0)
        !           197:                        goto xfail;
        !           198:                sfree (c);
        !           199:                goto xsuc;
        !           200:        case 2: /*  r a g */
        !           201:                ca = r->p1;
        !           202:                a = ca->p1;
        !           203:                b = eval (r->p2, 0);
        !           204:                assign (b, eval (ca->p2, 1));
        !           205:                goto xsuc;
        !           206:        case 3: /*  r m a g */
        !           207:                m = r->p1;
        !           208:                ca = m->p1;
        !           209:                a = ca->p1;
        !           210:                b = eval (r->p2, 0);
        !           211:                d = search (m, b->p2);
        !           212:                if (d == 0)
        !           213:                        goto xfail;
        !           214:                c = eval (ca->p2, 1);
        !           215:                if (d->p1 == 0) {
        !           216:                        sfree (d);
        !           217:                        assign (b, cat (c, b->p2));
        !           218:                        delete (c);
        !           219:                        goto xsuc;
        !           220:                }
        !           221:                if (d->p2 == b->p2->p2) {
        !           222:                        assign (b, c);
        !           223:                        sfree (d);
        !           224:                        goto xsuc;
        !           225:                }
        !           226:                (r=salloc())->p1 = d->p2->p1;
        !           227:                r->p2 = b->p2->p2;
        !           228:                assign (b, cat (c, r));
        !           229:                sfree (d);
        !           230:                sfree (r);
        !           231:                delete (c);
        !           232:                goto xsuc;
        !           233:        }
        !           234: xsuc:
        !           235:        if (rfail)
        !           236:                goto xfail;
        !           237:        b = a->p1;
        !           238:        goto xboth;
        !           239: xfail:
        !           240:        rfail = 0;
        !           241:        b = a->p2;
        !           242: xboth:
        !           243:        if (b == 0) {
        !           244:                return (e->p1);
        !           245:        }
        !           246:        b = eval (b, 0);
        !           247:        if (b == lookret)
        !           248:                return (0);
        !           249:        if (b == lookfret) {
        !           250:                rfail = 1;
        !           251:                return (0);
        !           252:        }
        !           253:        if (b->typ!=2)
        !           254:                writes ("attempt to transfer to non-label");
        !           255:        return (b->p2);
        !           256: }
        !           257: 
        !           258: assign (adr, val)
        !           259:        struct node *adr, *val;
        !           260: {
        !           261:        register struct node *a, *addr, *value;
        !           262: 
        !           263:        addr = adr;
        !           264:        value = val;
        !           265:        if (rfail == 1) {
        !           266:                delete (value);
        !           267:                return;
        !           268:        }
        !           269:        switch (addr->typ) {
        !           270:        default:
        !           271:                writes ("attempt to make an illegal assignment");
        !           272:        case 0:
        !           273:                addr->typ = 1;
        !           274:        case 1:
        !           275:                delete (addr->p2);
        !           276:                addr->p2 = value;
        !           277:                return;
        !           278:        case 4:
        !           279:                sysput (value);
        !           280:                return;
        !           281:        case 5:
        !           282:                a = addr->p2->p1;
        !           283:                delete (a->p2);
        !           284:                a->p2 = value;
        !           285:                return;
        !           286:        }
        !           287: }

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