Return to ac.c CVS log

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

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

1.1       root        1: #include "apl.h"
                      2: 
                      3: ex_rot0()
                      4: {
                      5: 
                      6:        fetch2();
                      7:        rotk(0);
                      8: }
                      9: 
                     10: ex_rotk()
                     11: {
                     12:        register k;
                     13: 
                     14:        k = topfix() - thread.iorg;
                     15:        fetch2();
                     16:        rotk(k);
                     17: }
                     18: 
                     19: ex_rot()
                     20: {
                     21:        register struct item *p;
                     22: 
                     23:        fetch2();
                     24:        p = sp[-2];
                     25:        rotk(p->rank-1);
                     26: }
                     27: 
                     28: rotk(k)
                     29: {
                     30:        register struct item *p, *q;
                     31:        register param;
                     32:        int rot1();
                     33: 
                     34:        p = sp[-1];
                     35:        bidx(sp[-2]);
                     36:        if(k < 0 || k >= idx.rank)
                     37:                error("rotate X");
                     38:        param = 0;
                     39:        colapse(k);
                     40:        if(idx.size != p->size) {
                     41:                if(p->size != 1)
                     42:                        error("rotate C");
                     43:                param++;
                     44:                datum = getdat(p);
                     45:        }
                     46:        p = newdat(idx.type, 1, idx.dimk);
                     47:        push(p);
                     48:        forloop(rot1, param);
                     49:        pop();
                     50:        pop();
                     51: }
                     52: 
                     53: rot1(param)
                     54: {
                     55:        register struct item *p, *q;
                     56:        register i;
                     57:        int o, n;
                     58: 
                     59:        if(param == 0)
                     60:                datum = getdat(sp[-2]);
                     61:        o = fix(datum);
                     62:        if(o < 0)
                     63:                o = idx.dimk - (-o % idx.dimk);
                     64:        q = sp[-1];
                     65:        p = sp[-3];
                     66:        q->index = 0;
                     67:        n = access();
                     68:        for(i=0; i<idx.dimk; i++) {
                     69:                p->index = n + (o%idx.dimk)*idx.delk;
                     70:                putdat(q, getdat(p));
                     71:                o++;
                     72:        }
                     73:        for(i=0; i<idx.dimk; i++) {
                     74:                p->index = n;
                     75:                putdat(p, getdat(q));
                     76:                n =+ idx.delk;
                     77:        }
                     78: }

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