Return to a4.c CVS log

Up to [CSRG BSD Unix] / 41BSD / cmd / apl

Annotation of 41BSD/cmd/apl/a4.c, revision 1.1.1.1

1.1       root        1: #include "apl.h"
                      2: 
                      3: ex_asgn()
                      4: {
                      5:        register struct nlist *p;
                      6:        register struct item *q;
                      7: 
                      8:        p = sp[-1];
                      9:        if(p->type == QD) {
                     10:                pop();
                     11:                ex_print();
                     12:                return;
                     13:        }
                     14:        if(p->type == QC) {
                     15:                pop();
                     16:                ex_plot();
                     17:                return;
                     18:        }
                     19:        if(p->type != LV)
                     20:                error("asgn lv");
                     21:        if(p->use != 0 && p->use != DA)
                     22:                error("asgn var");
                     23:        sp--;
                     24:        q = fetch1();
                     25:        erase(p);
                     26:        p->use = DA;
                     27:        p->itemp = q;
                     28:        sp[-1] = p;
                     29: }
                     30: 
                     31: ex_elid()
                     32: {
                     33: 
                     34:        push(newdat(EL,0,0));
                     35: }
                     36: 
                     37: ex_index()
                     38: {
                     39:        register struct item *p;
                     40:        struct item *q;
                     41:        register i, j;
                     42:        int f, n, lv;
                     43: 
                     44:        n = *pcp++;
                     45:        f = *pcp;
                     46:        p = sp[-1];
                     47:        if(f == ASGN) {
                     48:                pcp++;
                     49:                if(p->type != LV)
                     50:                        error("indexed assign value");
                     51:                if(p->use != DA)
                     52:                        fetch1(); /* error("used before set"); */
                     53:                q = p->itemp;
                     54:        } else
                     55:                q = fetch1();
                     56:        if(q->rank != n)
                     57:                error("subscript C");
                     58:        idx.rank = 0;
                     59:        for(i=0; i<n; i++) {
                     60:                p = sp[-i-2];
                     61:                if(p->type == EL) {
                     62:                        idx.dim[idx.rank++] =
                     63:                                q->dim[i];
                     64:                        continue;
                     65:                }
                     66:                p = fetch(p);
                     67:                sp[-i-2] = p;
                     68:                for(j=0; j<p->rank; j++)
                     69:                        idx.dim[idx.rank++] =
                     70:                                p->dim[j];
                     71:        }
                     72:        size();
                     73:        if(f == ASGN) {
                     74:                p = fetch(sp[-n-2]);
                     75:                sp[-n-2] = p;
                     76:                if(p->size > 1) {
                     77:                        if(idx.size != p->size)
                     78:                                error("assign C");
                     79:                        f = 1; /* v[i] <- v */
                     80:                } else {
                     81:                        datum = getdat(p);
                     82:                        f = 2; /* v[i] <- s */
                     83:                }
                     84:                ex_elid();
                     85:        } else {
                     86:                p = newdat(q->type, idx.rank, idx.size);
                     87:                copy(IN, idx.dim, p->dim, idx.rank);
                     88:                push(p);
                     89:                f = 0; /* v[i] */
                     90:        }
                     91:        bidx(q);
                     92:        index1(0, f);
                     93:        if(f == 0) {
                     94:                p = sp[-1];
                     95:                sp--;
                     96:                for(i=0; i<=n; i++)
                     97:                        pop();
                     98:                push(p);
                     99:        } else {
                    100:                sp -= 2;
                    101:                for(i=0; i<n; i++)
                    102:                        pop();
                    103:        }
                    104: }
                    105: 
                    106: index1(i, f)
                    107: {
                    108:        register struct item *p;
                    109:        register j, k;
                    110: 
                    111:        if(i >= idx.rank)
                    112:        switch(f) {
                    113: 
                    114:        case 0:
                    115:                p = sp[-2];
                    116:                p->index = access();
                    117:                putdat(sp[-1], getdat(p));
                    118:                return;
                    119: 
                    120:        case 1:
                    121:                datum = getdat(sp[-idx.rank-3]);
                    122: 
                    123:        case 2:
                    124:                p = sp[-2]->itemp;
                    125:                p->index = access();
                    126:                putdat(p, datum);
                    127:                return;
                    128:        }
                    129:        p = sp[-i-3];
                    130:        if(p->type == EL) {
                    131:                for(j=0; j<idx.dim[i]; j++) {
                    132:                        idx.idx[i] = j;
                    133:                        index1(i+1, f);
                    134:                }
                    135:                return;
                    136:        }
                    137:        p->index = 0;
                    138:        for(j=0; j<p->size; j++) {
                    139:                k = fix(getdat(p)) - thread.iorg;
                    140:                if(k < 0 || k > idx.dim[i])
                    141:                        error("subscript X");
                    142:                idx.idx[i] = k;
                    143:                index1(i+1, f);
                    144:        }
                    145: }

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