Return to CTTOT.c CVS log

Up to [CSRG BSD Unix] / 40BSD / lib / libpc

Annotation of 40BSD/lib/libpc/CTTOT.c, revision 1.1.1.1

1.1       root        1: /* Copyright (c) 1979 Regents of the University of California */
                      2: 
                      3: static char sccsid[] = "@(#)CTTOT.c 1.1 10/29/80";
                      4: 
                      5: #include "h00vars.h"
                      6: #include "h01errs.h"
                      7: 
                      8: long   _mask[] = {     
                      9:                    0xffffffff , 0xfffffffe , 0xfffffffc , 0xfffffff8 ,
                     10:                    0xfffffff0 , 0xffffffe0 , 0xffffffc0 , 0xffffff80 ,
                     11:                    0xffffff00 , 0xfffffe00 , 0xfffffc00 , 0xfffff800 ,
                     12:                    0xfffff000 , 0xffffe000 , 0xffffc000 , 0xffff8000 ,
                     13:                    0xffff0000 , 0xfffe0000 , 0xfffc0000 , 0xfff80000 ,
                     14:                    0xfff00000 , 0xffe00000 , 0xffc00000 , 0xff800000 ,
                     15:                    0xff000000 , 0xfe000000 , 0xfc000000 , 0xf8000000 ,
                     16:                    0xf0000000 , 0xe0000000 , 0xc0000000 , 0x80000000 ,
                     17:                    0x00000000
                     18:                 };
                     19: /*
                     20:  * Constant set constructor
                     21:  */
                     22: 
                     23: long *
                     24: CTTOT(result, lowerbnd, upperbnd, paircnt, singcnt, data)
                     25: 
                     26:        long    *result;        /* pointer to final set */
                     27:        int     lowerbnd;       /* lower bound of set */
                     28:        int     upperbnd;       /* upper - lower of set */
                     29:        int     paircnt;        /* number of pairs to construct */
                     30:        int     singcnt;        /* number of singles to construct */
                     31:        int     data;           /* paircnt plus singcnt sets of data */
                     32: {
                     33:        register int    lower;
                     34:        register int    lowerdiv;
                     35:        register int    lowermod;
                     36:        register int    upper;
                     37:        int             upperdiv;
                     38:        int             uppermod;
                     39:        register int    *dataptr;
                     40:        register long   *lp;
                     41:        long            *limit;
                     42:        long            temp;
                     43:        long            cnt;
                     44: 
                     45:        limit = &result[(upperbnd + 1 + BITSPERLONG - 1) / BITSPERLONG];
                     46:        for (lp = result; lp < limit; )
                     47:                *lp++ = 0;
                     48:        dataptr = &data;
                     49:        for (cnt = 0; cnt < paircnt; cnt++) {
                     50:                upper = *dataptr++ - lowerbnd;
                     51:                if (upper < 0 || upper > upperbnd) {
                     52:                        ERROR(ECTUPR, *--dataptr);
                     53:                        return;
                     54:                }
                     55:                lower = *dataptr++ - lowerbnd;
                     56:                if (lower < 0 || lower > upperbnd) {
                     57:                        ERROR(ECTLWR, *--dataptr);
                     58:                        return;
                     59:                }
                     60:                if (lower > upper) {
                     61:                        continue;
                     62:                }
                     63:                lowerdiv = lower / BITSPERLONG;
                     64:                lowermod = lower % BITSPERLONG;
                     65:                upperdiv = upper / BITSPERLONG;
                     66:                uppermod = upper % BITSPERLONG;
                     67:                temp = _mask [lowermod];
                     68:                if ( lowerdiv == upperdiv ) {
                     69:                        temp &= ~_mask[ uppermod + 1 ];
                     70:                }
                     71:                result[ lowerdiv ] |= temp;
                     72:                limit = &result[ upperdiv-1 ];
                     73:                for ( lp = &result[ lowerdiv+1 ] ; lp <= limit ; lp++ ) {
                     74:                        *lp |= ~0;
                     75:                }
                     76:                if ( lowerdiv != upperdiv ) {
                     77:                        result[ upperdiv ] |= ~_mask[ uppermod + 1 ];
                     78:                }
                     79:        }
                     80:        for (cnt = 0; cnt < singcnt; cnt++) {
                     81:                lower = *dataptr++ - lowerbnd;
                     82:                if (lower < 0 || lower > upperbnd) {
                     83:                        ERROR(ECTSNG, *--dataptr);
                     84:                        return;
                     85:                }
                     86:                lowerdiv = lower / BITSPERLONG;
                     87:                lowermod = lower % BITSPERLONG;
                     88:                result[ lowerdiv ] |= ( 1 << lowermod );
                     89:        }
                     90:        return(result);
                     91: }

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