Return to utilities.c CVS log

Up to [CSRG BSD Unix] / 40BSD / cmd / px

Annotation of 40BSD/cmd/px/utilities.c, revision 1.1

1.1     ! root        1: /* Copyright (c) 1979 Regents of the University of California */
        !             2: 
        !             3: static char sccsid[] = "@(#)utilities.c 4.2 10/20/80";
        !             4: 
        !             5: #include       "stdio.h"
        !             6: #include       "h00vars.h"
        !             7: #include       "h01errs.h"
        !             8: #include       "h02opcs.h"
        !             9: 
        !            10: /*
        !            11:  * allocate a block of storage on the heap
        !            12:  */
        !            13: char   *palloc(need)
        !            14: 
        !            15: long   need;
        !            16: 
        !            17: {
        !            18: extern  char *malloc();
        !            19: register char *memblk, *ptr;
        !            20: 
        !            21: memblk = malloc(need);
        !            22: if (memblk == 0)
        !            23:        error(EOUTOFMEM);
        !            24: if (memblk == (char *)(-1))
        !            25:        error(ETRASHHEAP);
        !            26: for(ptr=memblk; ptr<memblk+need; ptr++)
        !            27:        *ptr = 0;
        !            28: return(memblk);
        !            29: }
        !            30: 
        !            31: 
        !            32: 
        !            33: /*
        !            34:  * Free a block of storage on the stack
        !            35:  */
        !            36: pfree(ptr)
        !            37: 
        !            38: char   *ptr;
        !            39: 
        !            40: {
        !            41: extern long free();
        !            42: 
        !            43: if (ptr == 0)
        !            44:        error(ENILPTR);
        !            45: else if (free(ptr) == -1)
        !            46:        error(ETRASHHEAP);
        !            47: }
        !            48: 
        !            49: long   _mask[] = {     
        !            50:                    0xffffffff , 0xfffffffe , 0xfffffffc , 0xfffffff8 ,
        !            51:                    0xfffffff0 , 0xffffffe0 , 0xffffffc0 , 0xffffff80 ,
        !            52:                    0xffffff00 , 0xfffffe00 , 0xfffffc00 , 0xfffff800 ,
        !            53:                    0xfffff000 , 0xffffe000 , 0xffffc000 , 0xffff8000 ,
        !            54:                    0xffff0000 , 0xfffe0000 , 0xfffc0000 , 0xfff80000 ,
        !            55:                    0xfff00000 , 0xffe00000 , 0xffc00000 , 0xff800000 ,
        !            56:                    0xff000000 , 0xfe000000 , 0xfc000000 , 0xf8000000 ,
        !            57:                    0xf0000000 , 0xe0000000 , 0xc0000000 , 0x80000000 ,
        !            58:                    0x00000000
        !            59:                 };
        !            60: /*
        !            61:  * Constant set constructor
        !            62:  */
        !            63: 
        !            64: long *
        !            65: cttot(result, lowerbnd, upperbnd, paircnt, singcnt, data)
        !            66: 
        !            67:        long    *result;        /* pointer to final set */
        !            68:        int     lowerbnd;       /* lower bound of set */
        !            69:        int     upperbnd;       /* upper - lower of set */
        !            70:        int     paircnt;        /* number of pairs to construct */
        !            71:        int     singcnt;        /* number of singles to construct */
        !            72:        int     data;           /* paircnt plus singcnt sets of data */
        !            73: {
        !            74:        register int    lower;
        !            75:        register int    lowerdiv;
        !            76:        register int    lowermod;
        !            77:        register int    upper;
        !            78:        int             upperdiv;
        !            79:        int             uppermod;
        !            80:        register int    *dataptr;
        !            81:        register long   *lp;
        !            82:        long            *limit;
        !            83:        long            temp;
        !            84:        long            cnt;
        !            85: 
        !            86:        limit = &result[(upperbnd + 1 + BITSPERLONG - 1) / BITSPERLONG];
        !            87:        for (lp = result; lp < limit; )
        !            88:                *lp++ = 0;
        !            89:        dataptr = &data;
        !            90:        for (cnt = 0; cnt < paircnt; cnt++) {
        !            91:                lower = *dataptr++ - lowerbnd;
        !            92:                if (lower < 0 || lower > upperbnd) {
        !            93:                        error(ECTLWR);
        !            94:                        return;
        !            95:                }
        !            96:                upper = *dataptr++ - lowerbnd;
        !            97:                if (upper < 0 || upper > upperbnd) {
        !            98:                        error(ECTUPR);
        !            99:                        return;
        !           100:                }
        !           101:                if (lower > upper) {
        !           102:                        continue;
        !           103:                }
        !           104:                lowerdiv = lower / BITSPERLONG;
        !           105:                lowermod = lower % BITSPERLONG;
        !           106:                upperdiv = upper / BITSPERLONG;
        !           107:                uppermod = upper % BITSPERLONG;
        !           108:                temp = _mask [lowermod];
        !           109:                if ( lowerdiv == upperdiv ) {
        !           110:                        temp &= ~_mask[ uppermod + 1 ];
        !           111:                }
        !           112:                result[ lowerdiv ] |= temp;
        !           113:                limit = &result[ upperdiv-1 ];
        !           114:                for ( lp = &result[ lowerdiv+1 ] ; lp <= limit ; lp++ ) {
        !           115:                        *lp |= ~0;
        !           116:                }
        !           117:                if ( lowerdiv != upperdiv ) {
        !           118:                        result[ upperdiv ] |= ~_mask[ uppermod + 1 ];
        !           119:                }
        !           120:        }
        !           121:        for (cnt = 0; cnt < singcnt; cnt++) {
        !           122:                lower = *dataptr++ - lowerbnd;
        !           123:                if (lower < 0 || lower > upperbnd) {
        !           124:                        error(ECTSNG);
        !           125:                        return;
        !           126:                }
        !           127:                lowerdiv = lower / BITSPERLONG;
        !           128:                lowermod = lower % BITSPERLONG;
        !           129:                result[ lowerdiv ] |= ( 1 << lowermod );
        !           130:        }
        !           131:        return(result);
        !           132: }
        !           133: 
        !           134: inct(element, paircnt, singcnt, data)
        !           135: 
        !           136:        register int    element;        /* element to find */
        !           137:        int             paircnt;        /* number of pairs to check */
        !           138:        int             singcnt;        /* number of singles to check */
        !           139:        int             data;           /* paircnt plus singcnt bounds */
        !           140: {
        !           141:        register int    *dataptr;
        !           142:        register int    cnt;
        !           143: 
        !           144:        dataptr = &data;
        !           145:        for (cnt = 0; cnt < paircnt; cnt++) {
        !           146:                if (element < *dataptr++) {
        !           147:                        dataptr++;
        !           148:                        continue;
        !           149:                }
        !           150:                if (element <= *dataptr++) {
        !           151:                        return TRUE;
        !           152:                }
        !           153:        }
        !           154:        for (cnt = 0; cnt < singcnt; cnt++) {
        !           155:                if (element == *dataptr++) {
        !           156:                        return TRUE;
        !           157:                }
        !           158:        }
        !           159:        return FALSE;
        !           160: }
        !           161: 
        !           162: char   pd_date[] = {
        !           163:        8, 9, 10, 4, 5, 6, 10, 22, 23, 10, 0
        !           164: };
        !           165: 
        !           166: char *ctime();
        !           167: 
        !           168: pdattim(op, alfap)
        !           169: register char *alfap;
        !           170: {
        !           171:        register char *ap, *cp, *dp;
        !           172:        long a;
        !           173:        int i;
        !           174: 
        !           175:        time(&a);
        !           176:        cp = ctime(&a);
        !           177:        ap = alfap;
        !           178:        if (op == O_DATE)
        !           179:                for (dp = pd_date; *dp; *ap++ = cp[*dp++]);
        !           180:        else
        !           181:                for (cp = cp + 10, i = 10; i; *ap++ = *cp++, i--);
        !           182: }
        !           183: 
        !           184: psexit(code)
        !           185: 
        !           186: long   code;
        !           187: {
        !           188: 
        !           189: pmflush();
        !           190: if (mode == PIX) {
        !           191:        fputs("Execution terminated",stderr);
        !           192:        if (code)
        !           193:                fputs(" abnormally",stderr);
        !           194:        fputc('.',stderr);
        !           195:        fputc('\n',stderr);
        !           196:        }
        !           197: stats();
        !           198: exit(code);
        !           199: }

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