Return to aa.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / apl / src

Annotation of 43BSD/contrib/apl/src/aa.c, revision 1.1

1.1     ! root        1: static char Sccsid[] = "aa.c @(#)aa.c  1.1     10/1/82 Berkeley ";
        !             2: #include "apl.h"
        !             3: 
        !             4: int    gdu();
        !             5: int    gdd();
        !             6: 
        !             7: ex_gdu()
        !             8: {
        !             9:        register struct item *p;
        !            10: 
        !            11:        p = fetch1();
        !            12:        gd0(p->rank-1, gdu);
        !            13: }
        !            14: 
        !            15: ex_gduk()
        !            16: {
        !            17:        register k;
        !            18: 
        !            19:        k = topfix() - thread.iorg;
        !            20:        fetch1();
        !            21:        gd0(k, gdu);
        !            22: }
        !            23: 
        !            24: ex_gdd()
        !            25: {
        !            26:        register struct item *p;
        !            27: 
        !            28:        p = fetch1();
        !            29:        gd0(p->rank-1, gdd);
        !            30: }
        !            31: 
        !            32: ex_gddk()
        !            33: {
        !            34:        register k;
        !            35: 
        !            36:        k = topfix() - thread.iorg;
        !            37:        fetch1();
        !            38:        gd0(k, gdd);
        !            39: }
        !            40: 
        !            41: gd0(k, f)
        !            42: int (*f)();
        !            43: {
        !            44:        register struct item *p;
        !            45:        char *param[2];
        !            46:        int gd1();
        !            47: 
        !            48:        bidx(sp[-1]);
        !            49:        if(k < 0 || k >= idx.rank)
        !            50:                error("grade X");
        !            51:        p = newdat(DA, idx.rank, idx.size);
        !            52:        copy(IN, idx.dim, p->dim, idx.rank);
        !            53:        *sp++ = p;
        !            54:        colapse(k);
        !            55:        param[0] = alloc(idx.dimk*SINT);
        !            56:        param[1] = (char *)f;
        !            57:        forloop(gd1, param);
        !            58:        free(param[0]);
        !            59:        p = sp[-1];
        !            60:        sp--;
        !            61:        pop();
        !            62:        *sp++ = p;
        !            63: }
        !            64: 
        !            65: gd1(param)
        !            66: int *param[];
        !            67: {
        !            68:        register struct item *p;
        !            69:        register i, *m;
        !            70: 
        !            71:        integ = access();
        !            72:        m = param[0];
        !            73:        for(i=0; i<idx.dimk; i++)
        !            74:                *m++ = i;
        !            75:        m = param[0];
        !            76:        qsort(m, idx.dimk, SINT, param[1]);
        !            77:        p = sp[-1];
        !            78:        for(i=0; i<idx.dimk; i++) {
        !            79:                p->index = integ;
        !            80:                datum = *m++ + thread.iorg;
        !            81:                putdat(p, datum);
        !            82:                integ += idx.delk;
        !            83:        }
        !            84: }
        !            85: 
        !            86: gdu(p1, p2)
        !            87: int *p1, *p2;
        !            88: {
        !            89:        register struct item *p;
        !            90:        data d1, d2;
        !            91: 
        !            92:        p = sp[-2];
        !            93:        p->index = integ + *p1 * idx.delk;
        !            94:        d1 = getdat(p);
        !            95:        p->index = integ + *p2 * idx.delk;
        !            96:        d2 = getdat(p);
        !            97:        if(fuzz(d1, d2) != 0) {
        !            98:                if(d1 > d2)
        !            99:                        return(1);
        !           100:                return(-1);
        !           101:        }
        !           102:        return(*p1 - *p2);
        !           103: }
        !           104: 
        !           105: gdd(p1, p2)
        !           106: int *p1, *p2;
        !           107: {
        !           108:        register struct item *p;
        !           109:        data d1, d2;
        !           110: 
        !           111:        p = sp[-2];
        !           112:        p->index = integ + *p1 * idx.delk;
        !           113:        d1 = getdat(p);
        !           114:        p->index = integ + *p2 * idx.delk;
        !           115:        d2 = getdat(p);
        !           116:        if(fuzz(d1, d2) != 0) {
        !           117:                if(d1 > d2)
        !           118:                        return(-1);
        !           119:                return(1);
        !           120:        }
        !           121:        return(*p1 - *p2);
        !           122: }

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