Return to ialloc.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / share / zoneinfo

Annotation of 43BSDReno/share/zoneinfo/ialloc.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: #ifndef NOID
        !             3: static char    elsieid[] = "@(#)ialloc.c       8.18";
        !             4: #endif /* !defined NOID */
        !             5: #endif /* !defined lint */
        !             6: 
        !             7: /*LINTLIBRARY*/
        !             8: 
        !             9: #include "string.h"
        !            10: #include "stdlib.h"
        !            11: #include "nonstd.h"
        !            12: 
        !            13: #ifdef MAL
        !            14: #define NULLMAL(x)     ((x) == NULL || (x) == MAL)
        !            15: #else /* !defined MAL */
        !            16: #define NULLMAL(x)     ((x) == NULL)
        !            17: #endif /* !defined MAL */
        !            18: 
        !            19: #define nonzero(n)     (((n) == 0) ? 1 : (n))
        !            20: 
        !            21: char * icalloc P((int nelem, int elsize));
        !            22: char * icatalloc P((char * old, const char * new));
        !            23: char * icpyalloc P((const char * string));
        !            24: char * imalloc P((int n));
        !            25: char * irealloc P((char * pointer, int size));
        !            26: void   ifree P((char * pointer));
        !            27: 
        !            28: char *
        !            29: imalloc(n)
        !            30: const int      n;
        !            31: {
        !            32: #ifdef MAL
        !            33:        register char * result;
        !            34: 
        !            35:        result = malloc((alloc_size_t) nonzero(n));
        !            36:        return NULLMAL(result) ? NULL : result;
        !            37: #else /* !defined MAL */
        !            38:        return malloc((alloc_size_t) nonzero(n));
        !            39: #endif /* !defined MAL */
        !            40: }
        !            41: 
        !            42: char *
        !            43: icalloc(nelem, elsize)
        !            44: int    nelem;
        !            45: int    elsize;
        !            46: {
        !            47:        if (nelem == 0 || elsize == 0)
        !            48:                nelem = elsize = 1;
        !            49:        return calloc((alloc_size_t) nelem, (alloc_size_t) elsize);
        !            50: }
        !            51: 
        !            52: char *
        !            53: irealloc(pointer, size)
        !            54: char * const   pointer;
        !            55: const int      size;
        !            56: {
        !            57:        if (NULLMAL(pointer))
        !            58:                return imalloc(size);
        !            59:        return realloc((genericptr_t) pointer, (alloc_size_t) nonzero(size));
        !            60: }
        !            61: 
        !            62: char *
        !            63: icatalloc(old, new)
        !            64: char * const           old;
        !            65: const char * const     new;
        !            66: {
        !            67:        register char * result;
        !            68:        register        oldsize, newsize;
        !            69: 
        !            70:        newsize = NULLMAL(new) ? 0 : strlen(new);
        !            71:        if (NULLMAL(old))
        !            72:                oldsize = 0;
        !            73:        else if (newsize == 0)
        !            74:                return old;
        !            75:        else    oldsize = strlen(old);
        !            76:        if ((result = irealloc(old, oldsize + newsize + 1)) != NULL)
        !            77:                if (!NULLMAL(new))
        !            78:                        (void) strcpy(result + oldsize, new);
        !            79:        return result;
        !            80: }
        !            81: 
        !            82: char *
        !            83: icpyalloc(string)
        !            84: const char * const     string;
        !            85: {
        !            86:        return icatalloc((char *) NULL, string);
        !            87: }
        !            88: 
        !            89: void
        !            90: ifree(p)
        !            91: char * const   p;
        !            92: {
        !            93:        if (!NULLMAL(p))
        !            94:                (void) free(p);
        !            95: }
        !            96: 
        !            97: void
        !            98: icfree(p)
        !            99: char * const   p;
        !           100: {
        !           101:        if (!NULLMAL(p))
        !           102:                (void) free(p);
        !           103: }

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