boilerplate/cairo-boilerplate-system.c

   1 /*
   2  * Copyright © 2004 Red Hat, Inc.
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software
   5  * and its documentation for any purpose is hereby granted without
   6  * fee, provided that the above copyright notice appear in all copies
   7  * and that both that copyright notice and this permission notice
   8  * appear in supporting documentation, and that the name of
   9  * Red Hat, Inc. not be used in advertising or publicity pertaining to
  10  * distribution of the software without specific, written prior
  11  * permission. Red Hat, Inc. makes no representations about the
  12  * suitability of this software for any purpose.  It is provided "as
  13  * is" without express or implied warranty.
  14  *
  15  * RED HAT, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  16  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17  * FITNESS, IN NO EVENT SHALL RED HAT, INC. BE LIABLE FOR ANY SPECIAL,
  18  * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  19  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  20  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
  21  * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22  *
  23  * Author: Carl D. Worth <cworth@cworth.org>
  24  */
  25
  26 #define _GNU_SOURCE 1 /* for vasprintf */
  27
  28 #include "cairo-boilerplate.h"
  29 #include "cairo-boilerplate-system.h"
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <stdarg.h>
  34 #ifdef HAVE_UNISTD_H
  35 #include <unistd.h>
  36 #endif
  37 #include <errno.h>
  38
  39 void *
  40 xmalloc (size_t size)
  41 {
  42     void *buf;
  43
  44     if (size == 0)
  45         return NULL;
  46
  47     buf = malloc (size);
  48     if (buf == NULL) {
  49         fprintf (stderr, "Error: Out of memory. Exiting.\n");
  50         exit (1);
  51     }
  52
  53     return buf;
  54 }
  55
  56 void *
  57 xcalloc (size_t nmemb,
  58          size_t size)
  59 {
  60     void *buf;
  61
  62     if (nmemb == 0 || size == 0)
  63         return NULL;
  64
  65     buf = calloc (nmemb, size);
  66     if (buf == NULL) {
  67         fprintf (stderr, "Error: Out of memory. Exiting\n");
  68         exit (1);
  69     }
  70
  71     return buf;
  72 }
  73
  74 void *
  75 xrealloc (void   *buf,
  76           size_t  size)
  77 {
  78     buf = realloc (buf, size);
  79     if (buf == NULL && size != 0) {
  80         fprintf (stderr, "Error: Out of memory. Exiting\n");
  81         exit (1);
  82     }
  83
  84     return buf;
  85 }
  86
  87 void
  88 xasprintf (char       **strp,
  89            const char  *fmt,
  90                         ...)
  91 {
  92 #ifdef HAVE_VASPRINTF
  93     va_list va;
  94     int ret;
  95
  96     va_start (va, fmt);
  97     ret = vasprintf (strp, fmt, va);
  98     va_end (va);
  99
 100     if (ret < 0) {
 101         fprintf (stderr, "Error: Out of memory. Exiting.\n");
 102         exit (1);
 103     }
 104 #else /* !HAVE_VASNPRINTF */
 105 #define BUF_SIZE 1024
 106     va_list va;
 107     char buffer[BUF_SIZE];
 108     int ret, len;
 109
 110     va_start (va, fmt);
 111     ret = vsnprintf (buffer, sizeof (buffer), fmt, va);
 112     va_end (va);
 113
 114     if (ret < 0) {
 115         fprintf (stderr, "Failure in vsnprintf\n");
 116         exit (1);
 117     }
 118
 119     len = (ret + sizeof (int)) & -sizeof (int);
 120     *strp = malloc (len);
 121     if (*strp == NULL) {
 122         fprintf (stderr, "Out of memory\n");
 123         exit (1);
 124     }
 125
 126     if ((unsigned) ret < sizeof (buffer)) {
 127         memcpy (*strp, buffer, ret);
 128     } else {
 129         va_start (va, fmt);
 130         ret = vsnprintf (*strp, len, fmt, va);
 131         va_end (va);
 132
 133         if (ret >= len) {
 134             free (*strp);
 135             fprintf (stderr, "Overflowed dynamic buffer\n");
 136             exit (1);
 137         }
 138     }
 139     memset (*strp + ret, 0, len-ret);
 140 #endif /* !HAVE_VASNPRINTF */
 141 }
 142
 143 void
 144 xunlink (const char *pathname)
 145 {
 146     if (unlink (pathname) < 0 && errno != ENOENT) {
 147         fprintf (stderr, "Error: Cannot remove %s: %s\n",
 148                                pathname, strerror (errno));
 149         exit (1);
 150     }
 151 }
 152
 153 char *
 154 xstrdup (const char *str)
 155 {
 156     if (str == NULL)
 157         return NULL;
 158
 159     str = strdup (str);
 160     if (str == NULL) {
 161         fprintf (stderr, "Error: Out of memory. Exiting.\n");
 162         exit (1);
 163     }
 164
 165     return (char *) str;
 166 }