Return to LL.c CVS log

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

Annotation of researchv10no/cmd/worm/LL.c, revision 1.1

1.1     ! root        1: #include       <sys/param.h>
        !             2: 
        !             3: /*
        !             4:  * long-long support
        !             5:  */
        !             6: 
        !             7: #define        M 0x80000000
        !             8: 
        !             9: unsigned
        !            10: Lshift(ll, l)
        !            11: llong_t ll;
        !            12: long l;
        !            13: {
        !            14:        return (ll.hi<<(32-l)) | (ll.lo>>l);
        !            15: }
        !            16: 
        !            17: llong_t
        !            18: ltoL(l)
        !            19: long l;
        !            20: {
        !            21:        llong_t t;
        !            22: 
        !            23:        t.hi = 0;
        !            24:        t.lo = l;
        !            25:        return t;
        !            26: }
        !            27: 
        !            28: llong_t
        !            29: Lladd(ll, l)
        !            30: llong_t ll;
        !            31: long l;
        !            32: {
        !            33:        llong_t t;
        !            34:        long cin;
        !            35: 
        !            36:        t = ll;
        !            37:        t.lo += l;
        !            38:        cin = ll.lo^t.lo;
        !            39:        if (l>=0) {
        !            40:                if ((ll.lo&cin)&M)
        !            41:                        t.hi++;
        !            42:        } else {
        !            43:                if ((~ll.lo&cin)&M)
        !            44:                        t.hi--;
        !            45:        }
        !            46:        return t;
        !            47: }
        !            48: 
        !            49: llong_t
        !            50: Luadd(ll, u)
        !            51: llong_t ll;
        !            52: unsigned long u;
        !            53: {
        !            54:        llong_t t;
        !            55:        long cin;
        !            56: 
        !            57:        t = ll;
        !            58:        t.lo += u;
        !            59:        cin = ll.lo^t.lo;
        !            60:        if ((ll.lo&cin)&M)
        !            61:                t.hi++;
        !            62:        return t;
        !            63: }
        !            64: 
        !            65: llong_t
        !            66: LLadd(lla, llb)
        !            67: llong_t lla, llb;
        !            68: {
        !            69:        llong_t t;
        !            70: 
        !            71:        t.hi = lla.hi+llb.hi;
        !            72:        t.lo = lla.lo+llb.lo;
        !            73:        if ((lla.lo&llb.lo | lla.lo&~t.lo | llb.lo&~t.lo)&M)
        !            74:                t.hi++;
        !            75:        return t;
        !            76: }
        !            77: 
        !            78: llong_t
        !            79: Llmul(a, b)
        !            80:        llong_t a;
        !            81:        unsigned long b;
        !            82: {
        !            83:        llong_t r;
        !            84: 
        !            85:        r = ltoL(0);
        !            86:        while(b){
        !            87:                if(b&1)
        !            88:                        r = LLadd(r, a);
        !            89:                b >>= 1;
        !            90:                a = LLadd(a, a);
        !            91:        }
        !            92:        return(r);
        !            93: }

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