Return to xmalloc.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / tmux

Annotation of embedaddon/tmux/xmalloc.c, revision 1.1

1.1     ! misho       1: /* $OpenBSD$ */
        !             2: 
        !             3: /*
        !             4:  * Author: Tatu Ylonen <ylo@cs.hut.fi>
        !             5:  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
        !             6:  *                    All rights reserved
        !             7:  * Versions of malloc and friends that check their results, and never return
        !             8:  * failure (they call fatalx if they encounter an error).
        !             9:  *
        !            10:  * As far as I am concerned, the code I have written for this software
        !            11:  * can be used freely for any purpose.  Any derived versions of this
        !            12:  * software must be clearly marked as such, and if the derived work is
        !            13:  * incompatible with the protocol description in the RFC file, it must be
        !            14:  * called by a name other than "ssh" or "Secure Shell".
        !            15:  */
        !            16: 
        !            17: #include <errno.h>
        !            18: #include <limits.h>
        !            19: #include <stdint.h>
        !            20: #include <stdio.h>
        !            21: #include <stdlib.h>
        !            22: #include <string.h>
        !            23: 
        !            24: #include "tmux.h"
        !            25: 
        !            26: void *
        !            27: xmalloc(size_t size)
        !            28: {
        !            29:        void *ptr;
        !            30: 
        !            31:        if (size == 0)
        !            32:                fatalx("xmalloc: zero size");
        !            33:        ptr = malloc(size);
        !            34:        if (ptr == NULL)
        !            35:                fatalx("xmalloc: allocating %zu bytes: %s",
        !            36:                    size, strerror(errno));
        !            37:        return ptr;
        !            38: }
        !            39: 
        !            40: void *
        !            41: xcalloc(size_t nmemb, size_t size)
        !            42: {
        !            43:        void *ptr;
        !            44: 
        !            45:        if (size == 0 || nmemb == 0)
        !            46:                fatalx("xcalloc: zero size");
        !            47:        ptr = calloc(nmemb, size);
        !            48:        if (ptr == NULL)
        !            49:                fatalx("xcalloc: allocating %zu * %zu bytes: %s",
        !            50:                    nmemb, size, strerror(errno));
        !            51:        return ptr;
        !            52: }
        !            53: 
        !            54: void *
        !            55: xrealloc(void *ptr, size_t size)
        !            56: {
        !            57:        return xreallocarray(ptr, 1, size);
        !            58: }
        !            59: 
        !            60: void *
        !            61: xreallocarray(void *ptr, size_t nmemb, size_t size)
        !            62: {
        !            63:        void *new_ptr;
        !            64: 
        !            65:        if (nmemb == 0 || size == 0)
        !            66:                fatalx("xreallocarray: zero size");
        !            67:        new_ptr = reallocarray(ptr, nmemb, size);
        !            68:        if (new_ptr == NULL)
        !            69:                fatalx("xreallocarray: allocating %zu * %zu bytes: %s",
        !            70:                    nmemb, size, strerror(errno));
        !            71:        return new_ptr;
        !            72: }
        !            73: 
        !            74: char *
        !            75: xstrdup(const char *str)
        !            76: {
        !            77:        char *cp;
        !            78: 
        !            79:        if ((cp = strdup(str)) == NULL)
        !            80:                fatalx("xstrdup: %s", strerror(errno));
        !            81:        return cp;
        !            82: }
        !            83: 
        !            84: char *
        !            85: xstrndup(const char *str, size_t maxlen)
        !            86: {
        !            87:        char *cp;
        !            88: 
        !            89:        if ((cp = strndup(str, maxlen)) == NULL)
        !            90:                fatalx("xstrndup: %s", strerror(errno));
        !            91:        return cp;
        !            92: }
        !            93: 
        !            94: int
        !            95: xasprintf(char **ret, const char *fmt, ...)
        !            96: {
        !            97:        va_list ap;
        !            98:        int i;
        !            99: 
        !           100:        va_start(ap, fmt);
        !           101:        i = xvasprintf(ret, fmt, ap);
        !           102:        va_end(ap);
        !           103: 
        !           104:        return i;
        !           105: }
        !           106: 
        !           107: int
        !           108: xvasprintf(char **ret, const char *fmt, va_list ap)
        !           109: {
        !           110:        int i;
        !           111: 
        !           112:        i = vasprintf(ret, fmt, ap);
        !           113: 
        !           114:        if (i < 0 || *ret == NULL)
        !           115:                fatalx("xasprintf: %s", strerror(errno));
        !           116: 
        !           117:        return i;
        !           118: }
        !           119: 
        !           120: int
        !           121: xsnprintf(char *str, size_t len, const char *fmt, ...)
        !           122: {
        !           123:        va_list ap;
        !           124:        int i;
        !           125: 
        !           126:        va_start(ap, fmt);
        !           127:        i = xvsnprintf(str, len, fmt, ap);
        !           128:        va_end(ap);
        !           129: 
        !           130:        return i;
        !           131: }
        !           132: 
        !           133: int
        !           134: xvsnprintf(char *str, size_t len, const char *fmt, va_list ap)
        !           135: {
        !           136:        int i;
        !           137: 
        !           138:        if (len > INT_MAX)
        !           139:                fatalx("xsnprintf: len > INT_MAX");
        !           140: 
        !           141:        i = vsnprintf(str, len, fmt, ap);
        !           142: 
        !           143:        if (i < 0 || i >= (int)len)
        !           144:                fatalx("xsnprintf: overflow");
        !           145: 
        !           146:        return i;
        !           147: }