Return to ak.c CVS log

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

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

1.1       root        1: #include "apl.h"
                      2: 
                      3: ex_scn0()
                      4: {
                      5:        fetch1();
                      6:        scan0(0);
                      7: }
                      8: 
                      9: ex_scan()
                     10: {
                     11:        register struct item *p;
                     12: 
                     13:        p = fetch1();
                     14:        scan0(p->rank-1);
                     15: }
                     16: 
                     17: ex_scnk()
                     18: {
                     19:        register i;
                     20: 
                     21:        i = topfix() - thread.iorg;
                     22:        scan0(i);
                     23: }
                     24: 
                     25: scan0(k)
                     26: {
                     27:        register struct item *p, *q;
                     28:        int param[2];
                     29:        int scan1();
                     30: 
                     31:        p = fetch1();
                     32:        if(p->type != DA)
                     33:                error("scan T");
                     34: 
                     35:        bidx(p);
                     36:        colapse(k);
                     37:        if(idx.dimk == 0) {
                     38: /*
                     39:  *  scan identities - ets/jrl 5/76
                     40:  */
                     41:                q = newdat(DA,0,1);
                     42:                q->dim[0] = 1;
                     43:                switch(*pcp++) {
                     44:        case ADD:
                     45:        case SUB:
                     46:        case OR:
                     47:                        q->datap[0] = 0;
                     48:                        break;
                     49:        case AND:
                     50:        case MUL:
                     51:        case DIV:
                     52:                        q->datap[0] = 1;
                     53:                        break;
                     54:        case MIN:
                     55:                        q->datap[0] = 1.0e38;
                     56:                        break;
                     57:        case MAX:
                     58:                        q->datap[0] = -1.0e38;
                     59:                        break;
                     60:        default:
                     61:                        error("reduce identity");
                     62:                }
                     63:                pop();
                     64:                push(q);
                     65:                return;
                     66:        }
                     67:        param[0] = p->datap;
                     68:        param[1] = exop[*pcp++];
                     69:        forloop(scan1, param);
                     70: }
                     71: 
                     72: scan1(param)
                     73: int param[];
                     74: {
                     75:        register i;
                     76:        register data *dp;
                     77:        data d;
                     78:        data (*f)();
                     79: 
                     80:        dp = param[0];
                     81:        f = param[1];
                     82:        dp =+ access();
                     83:        d = *dp;
                     84:        for(i = 1; i < idx.dimk; i++) {
                     85:                dp =+ idx.delk;
                     86:                *dp = d = (*f)(*dp, d);
                     87:        }
                     88: }
                     89: 
                     90: data scalex  453.;
                     91: data scaley  453.;
                     92: data origx  0.0;
                     93: data origy  0.0;
                     94: 
                     95: ex_plot()
                     96: {
                     97:        register struct item *p;
                     98:        register data *dp;
                     99:        register i;
                    100:        int ic;
                    101:        int x, y;
                    102: 
                    103:        p = fetch1();
                    104:        if(p->type != DA)
                    105:                error("plot T");
                    106:        if(p->rank != 2)
                    107:                error("plot R");
                    108:        if(p->dim[1] != 2)
                    109:                error("plot C");
                    110: 
                    111:        dp = p->datap;
                    112:        if ((i = p->dim[0]) == 0) return;
                    113:        ic=0;
                    114:        while(i--) {
                    115:                x = scalex*(*dp++ - origx);
                    116:                y = 454-(scaley*(*dp++ - origy));
                    117:                if(x<0 || x >= 576 ||
                    118:                 y<0 || y>=454)
                    119:                        error("plot off screen");
                    120:                if(ic)
                    121:                        line(x,y);
                    122:                else {
                    123:                        move(x,y);
                    124:                        ic=1;
                    125:                }
                    126:        }
                    127: }

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