Return to mlsb.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / pgrm / lisp / franz / tahoe

Annotation of 43BSDReno/pgrm/lisp/franz/tahoe/mlsb.c, revision 1.1.1.1

1.1       root        1: /* file: mlsb.c
                      2: ** functions: mlsb(), adback(), dsdiv(), dsadd1(), dsrsh()
                      3: /* Copyright (c) 1982, Regents, University of California */
                      4: 
                      5: struct vl              /* very long? */
                      6:        {long high;
                      7:         long low;
                      8:        };
                      9: 
                     10: long mlsb(utop,ubot,vtop,nqhat)
                     11: long *utop; register long *ubot, *vtop;
                     12: register nqhat;
                     13: {
                     14:        register handy, carry;
                     15:        struct vl work;
                     16:        
                     17:        for(carry = 0; utop >= ubot; utop--) {
                     18: 
                     19:                --vtop;
                     20:                asm("addl3 r8,*4(fp),r0");
                     21:                asm("emul r10,(r11),r0,-60(fp)");
                     22: 
                     23:                carry = work.high;
                     24:                handy = work.low;
                     25:                *utop = handy & 0x3fffffff;
                     26:                carry <<= 2;
                     27:                if(handy & 0x80000000) carry += 2;
                     28:                if(handy & 0x40000000) carry += 1;
                     29:        }
                     30:        return(carry);
                     31: }
                     32: 
                     33: long adback(utop,ubot,vtop)
                     34: register long *utop, *ubot, *vtop;
                     35: {
                     36:        register handy, carry;
                     37:        carry = 0;
                     38:        for(; utop >= ubot; utop--) {
                     39:                carry += *--vtop;
                     40:                carry += *utop;
                     41:                *utop = carry & 0x3fffffff;
                     42:                /* next junk is faster version of  carry >>= 30; */
                     43:                handy = carry;
                     44:                carry = 0;
                     45:                if(handy & 0x80000000) carry -= 2;
                     46:                if(handy & 0x40000000) carry += 1;
                     47:        }
                     48:        return(carry);
                     49: }
                     50: 
                     51: long dsdiv(top,bot,div)
                     52: register long *top, *bot;
                     53: register long div;
                     54: {
                     55:        struct vl work; char err;
                     56:        register long handy, carry = 0;
                     57:        for(carry = 0;bot <= top; bot++) {
                     58:                handy = *bot;
                     59:                if(carry & 1) handy |= 0x40000000;
                     60:                if(carry & 2) handy |= 0x80000000;
                     61:                carry >>= 2;
                     62:                work.low = handy;
                     63:                work.high = carry;
                     64:        /*      *bot = ediv(&work,div,&err); */
                     65:        /*      carry = work.high;           */
                     66:                asm("ediv r10,-60(fp),(r11),r8");
                     67:        }
                     68:        return(carry);
                     69: }
                     70: 
                     71: dsadd1(top,bot)
                     72: long *top, *bot;
                     73: {
                     74:        register long *p, work, carry = 0;
                     75: 
                     76:        /*
                     77:         * this assumes canonical inputs
                     78:         */
                     79:        for(p = top; p >= bot; p--) {
                     80:                work = *p + carry;
                     81:                *p = work & 0x3fffffff;
                     82:                carry = 0;
                     83:                if (work & 0x40000000) carry += 1;
                     84:                if (work & 0x80000000) carry -= 2;
                     85:        }
                     86:        p[1] = work;
                     87: }
                     88: 
                     89: long dsrsh(top,bot,ncnt,mask1)
                     90: long *top, *bot;
                     91: long ncnt, mask1;
                     92: {
                     93:        register long *p = bot;
                     94:        register r = -ncnt, l = 30+ncnt, carry = 0, work, save;
                     95:        long mask = -1 ^ mask1;
                     96: 
                     97:        while(p <= top) {
                     98:                save = work = *p; save &= mask; work >>= r;
                     99:                carry <<= l; work |= carry; *p++ = work;
                    100:                carry = save;
                    101:        }
                    102:        return(carry);
                    103: }

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