Return to utilities.c CVS log

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

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

1.1     ! root        1: #include       "stdio.h"
        !             2: #include       "h00vars.h"
        !             3: #include       "h01errs.h"
        !             4: #include       "h02opcs.h"
        !             5: 
        !             6: /*
        !             7:  * allocate a block of storage on the heap
        !             8:  */
        !             9: char   *palloc(need)
        !            10: 
        !            11: long   need;
        !            12: 
        !            13: {
        !            14: extern  char *malloc();
        !            15: register char *memblk, *ptr;
        !            16: 
        !            17: memblk = malloc(need);
        !            18: if (memblk == 0)
        !            19:        error(EOUTOFMEM);
        !            20: if (memblk == (char *)(-1))
        !            21:        error(ETRASHHEAP);
        !            22: for(ptr=memblk; ptr<memblk+need; ptr++)
        !            23:        *ptr = 0;
        !            24: return(memblk);
        !            25: }
        !            26: 
        !            27: 
        !            28: 
        !            29: /*
        !            30:  * Free a block of storage on the stack
        !            31:  */
        !            32: pfree(ptr)
        !            33: 
        !            34: char   *ptr;
        !            35: 
        !            36: {
        !            37: extern long free();
        !            38: 
        !            39: if (ptr == 0)
        !            40:        error(ENILPTR);
        !            41: else if (free(ptr) == -1)
        !            42:        error(ETRASHHEAP);
        !            43: }
        !            44: 
        !            45: /*
        !            46:  * Constant set constructor (yechh!)
        !            47:  */
        !            48: 
        !            49: #define        sets    int short
        !            50: 
        !            51: sets   *pcttot(uprbp, lwrb, n, av)
        !            52: 
        !            53: int    uprbp, lwrb, n;
        !            54: sets   av;
        !            55: 
        !            56: {
        !            57: register int l, h;
        !            58: register sets *set, *ap;
        !            59: 
        !            60:        ap = &av;
        !            61:        set = &ap[2 * n];
        !            62:        while(--n >= 0) {
        !            63:                if ((l = *ap++ - lwrb) < 0 || l > uprbp ||
        !            64:                    (h = *ap++ - lwrb) < 0 || h > uprbp)
        !            65:                        error(ECTTOT);
        !            66:                while (l <= h) {
        !            67:                        set[l >> 4] = set[l >> 4] | 1 << (l & 017);
        !            68:                        l++;
        !            69:                }
        !            70:        }
        !            71:        return(set);
        !            72: }
        !            73: 
        !            74: char   pd_date[] = {
        !            75:        8, 9, 10, 4, 5, 6, 10, 22, 23, 10, 0
        !            76: };
        !            77: 
        !            78: char *ctime();
        !            79: 
        !            80: pdattim(op, alfap)
        !            81: register char *alfap;
        !            82: {
        !            83:        register char *ap, *cp, *dp;
        !            84:        long a;
        !            85:        int i;
        !            86: 
        !            87:        time(&a);
        !            88:        cp = ctime(&a);
        !            89:        ap = alfap;
        !            90:        if (op == O_DATE)
        !            91:                for (dp = pd_date; *dp; *ap++ = cp[*dp++]);
        !            92:        else
        !            93:                for (cp = cp + 10, i = 10; i; *ap++ = *cp++, i--);
        !            94: }
        !            95: 
        !            96: psexit(code)
        !            97: 
        !            98: long   code;
        !            99: {
        !           100: 
        !           101: pmflush();
        !           102: if (mode == PIX && nodump == 0) {
        !           103:        fputs("Execution terminated",stderr);
        !           104:        if (code)
        !           105:                fputs(" abnormally",stderr);
        !           106:        fputc('.',stderr);
        !           107:        fputc('\n',stderr);
        !           108:        }
        !           109: stats();
        !           110: exit(code);
        !           111: }

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