Return to xmalloc.c CVS log

Up to [local] / src / usr.bin / tmux

Annotation of src/usr.bin/tmux/xmalloc.c, Revision 1.5

1.5     ! nicm        1: /* $OpenBSD: xmalloc.c,v 1.4 2012/07/10 11:53:01 nicm Exp $ */
1.1       nicm        2:
                      3: /*
                      4:  * Copyright (c) 2004 Nicholas Marriott <nicm@users.sourceforge.net>
                      5:  *
                      6:  * Permission to use, copy, modify, and distribute this software for any
                      7:  * purpose with or without fee is hereby granted, provided that the above
                      8:  * copyright notice and this permission notice appear in all copies.
                      9:  *
                     10:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
                     11:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
                     12:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
                     13:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
                     14:  * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
                     15:  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
                     16:  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
                     17:  */
                     18:
                     19: #include <sys/param.h>
                     20:
                     21: #include <errno.h>
                     22: #include <libgen.h>
                     23: #include <stdint.h>
                     24: #include <stdlib.h>
                     25: #include <string.h>
                     26:
                     27: #include "tmux.h"
                     28:
                     29: char *
                     30: xstrdup(const char *s)
                     31: {
1.2       nicm       32:        char    *ptr;
1.1       nicm       33:        size_t   len;
                     34:
                     35:        len = strlen(s) + 1;
                     36:        ptr = xmalloc(len);
                     37:
1.2       nicm       38:        strlcpy(ptr, s, len);
                     39:        return (ptr);
1.1       nicm       40: }
                     41:
                     42: void *
                     43: xcalloc(size_t nmemb, size_t size)
                     44: {
1.3       deraadt    45:        void    *ptr;
1.1       nicm       46:
1.3       deraadt    47:        if (size == 0 || nmemb == 0)
1.1       nicm       48:                fatalx("zero size");
1.3       deraadt    49:        if (SIZE_MAX / nmemb < size)
                     50:                fatalx("nmemb * size > SIZE_MAX");
                     51:        if ((ptr = calloc(nmemb, size)) == NULL)
1.1       nicm       52:                fatal("xcalloc failed");
                     53:
1.3       deraadt    54:        return (ptr);
1.1       nicm       55: }
                     56:
                     57: void *
                     58: xmalloc(size_t size)
                     59: {
                     60:        void    *ptr;
                     61:
1.3       deraadt    62:        if (size == 0)
                     63:                fatalx("zero size");
                     64:        if ((ptr = malloc(size)) == NULL)
1.1       nicm       65:                fatal("xmalloc failed");
                     66:
1.3       deraadt    67:        return (ptr);
1.1       nicm       68: }
                     69:
                     70: void *
1.5     ! nicm       71: xrealloc(void *oldptr, size_t newsize)
        !            72: {
        !            73:        void    *newptr;
        !            74:
        !            75:        if (newsize == 0)
        !            76:                fatalx("zero size");
        !            77:        if ((newptr = realloc(oldptr, newsize)) == NULL)
        !            78:                fatal("xrealloc failed");
        !            79:
        !            80:        return (newptr);
        !            81: }
        !            82:
        !            83: void *
        !            84: xreallocarray(void *oldptr, size_t nmemb, size_t size)
1.1       nicm       85: {
                     86:        size_t   newsize = nmemb * size;
                     87:        void    *newptr;
                     88:
                     89:        if (newsize == 0)
1.3       deraadt    90:                fatalx("zero size");
                     91:        if (SIZE_MAX / nmemb < size)
                     92:                fatalx("nmemb * size > SIZE_MAX");
                     93:        if ((newptr = realloc(oldptr, newsize)) == NULL)
1.5     ! nicm       94:                fatal("xreallocarray failed");
1.1       nicm       95:
1.3       deraadt    96:        return (newptr);
1.1       nicm       97: }
                     98:
                     99: int printflike2
                    100: xasprintf(char **ret, const char *fmt, ...)
                    101: {
1.3       deraadt   102:        va_list ap;
                    103:        int     i;
1.1       nicm      104:
1.3       deraadt   105:        va_start(ap, fmt);
                    106:        i = xvasprintf(ret, fmt, ap);
                    107:        va_end(ap);
1.1       nicm      108:
                    109:        return (i);
                    110: }
                    111:
                    112: int
                    113: xvasprintf(char **ret, const char *fmt, va_list ap)
                    114: {
                    115:        int     i;
                    116:
                    117:        i = vasprintf(ret, fmt, ap);
1.3       deraadt   118:        if (i < 0 || *ret == NULL)
                    119:                fatal("xvasprintf failed");
1.1       nicm      120:
1.3       deraadt   121:        return (i);
1.1       nicm      122: }
                    123:
                    124: int printflike3
                    125: xsnprintf(char *buf, size_t len, const char *fmt, ...)
                    126: {
1.3       deraadt   127:        va_list ap;
                    128:        int     i;
1.1       nicm      129:
1.3       deraadt   130:        va_start(ap, fmt);
                    131:        i = xvsnprintf(buf, len, fmt, ap);
                    132:        va_end(ap);
1.1       nicm      133:
                    134:        return (i);
                    135: }
                    136:
                    137: int
                    138: xvsnprintf(char *buf, size_t len, const char *fmt, va_list ap)
                    139: {
                    140:        int     i;
                    141:
                    142:        if (len > INT_MAX)
                    143:                fatalx("len > INT_MAX");
                    144:
                    145:        i = vsnprintf(buf, len, fmt, ap);
1.3       deraadt   146:        if (i < 0)
                    147:                fatal("vsnprintf failed");
1.1       nicm      148:
1.3       deraadt   149:        return (i);
1.1       nicm      150: }