Return to LL.c CVS log

Up to [Research Unix] / researchv10no / libc / gen

Annotation of researchv10no/libc/gen/LL.c, revision 1.1.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.