common/util.h

   1 /*
   2  * util.h - useful functions header
   3  *
   4  * Copyright © 2007-2008 Julien Danjou <julien@danjou.info>
   5  * Copyright © 2006 Pierre Habouzit <madcoder@debian.org>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  */
  22
  23 #ifndef AWESOME_COMMON_UTIL_H
  24 #define AWESOME_COMMON_UTIL_H
  25
  26 #include <string.h>
  27 #include <stdlib.h>
  28
  29 /** Link a name to a function */
  30 typedef struct
  31 {
  32     const char *name;
  33     void *func;
  34 } name_func_link_t;
  35
  36 /** \brief replace \c NULL strings with emtpy strings */
  37 #define NONULL(x)       (x ? x : "")
  38
  39 #undef MAX
  40 #undef MIN
  41 #define MAX(a,b) ((a) < (b) ? (b) : (a))
  42 #define MIN(a,b) ((a) < (b) ? (a) : (b))
  43
  44 #define ssizeof(foo)            (ssize_t)sizeof(foo)
  45 #define countof(foo)            (ssizeof(foo) / ssizeof(foo[0]))
  46
  47 #define p_new(type, count)      ((type *)xmalloc(sizeof(type) * (count)))
  48 #define p_clear(p, count)       ((void)memset((p), 0, sizeof(*(p)) * (count)))
  49 #define p_realloc(pp, count)    xrealloc((void*)(pp), sizeof(**(pp)) * (count))
  50 #define p_dup(p, count)         xmemdup((p), sizeof(*(p)) * (count))
  51
  52 #ifdef __GNUC__
  53
  54 #define p_delete(mem_pp)                           \
  55     do {                                           \
  56         typeof(**(mem_pp)) **__ptr = (mem_pp);     \
  57         free(*__ptr);                              \
  58         *__ptr = NULL;                             \
  59     } while(0)
  60
  61 #else
  62
  63 #define p_delete(mem_p)                            \
  64     do {                                           \
  65         void *__ptr = (mem_p);                     \
  66         free(*__ptr);                              \
  67         *(void **)__ptr = NULL;                    \
  68     } while (0)
  69
  70 #endif
  71
  72 static inline void * __attribute__ ((malloc)) xmalloc(ssize_t size)
  73 {
  74     void *ptr;
  75
  76     if(size <= 0)
  77         return NULL;
  78
  79     ptr = calloc(1, size);
  80
  81     if(!ptr)
  82         abort();
  83
  84     return ptr;
  85 }
  86
  87 static inline void
  88 xrealloc(void **ptr, ssize_t newsize)
  89 {
  90     if(newsize <= 0)
  91         p_delete(ptr);
  92     else
  93     {
  94         *ptr = realloc(*ptr, newsize);
  95         if(!*ptr)
  96             abort();
  97     }
  98 }
  99
 100 static inline void *xmemdup(const void *src, ssize_t size)
 101 {
 102     return memcpy(xmalloc(size), src, size);
 103 }
 104
 105 /** \brief \c NULL resistant strlen.
 106  *
 107  * Unlike it's libc sibling, a_strlen returns a ssize_t, and supports its
 108  * argument being NULL.
 109  *
 110  * \param[in] s the string.
 111  * \return the string length (or 0 if \c s is \c NULL).
 112  */
 113 static inline ssize_t a_strlen(const char *s)
 114 {
 115     return s ? strlen(s) : 0;
 116 }
 117
 118 /** \brief \c NULL resistant strnlen.
 119  *
 120  * Unlike it's GNU libc sibling, a_strnlen returns a ssize_t, and supports
 121  * its argument being NULL.
 122  *
 123  * The a_strnlen() function returns the number of characters in the string
 124  * pointed to by \c s, not including the terminating \c \\0 character, but at
 125  * most \c n. In doing this, a_strnlen() looks only at the first \c n
 126  * characters at \c s and never beyond \c s+n.
 127  *
 128  * \param[in]  s    the string.
 129  * \param[in]  n    the maximum length to return.
 130  * \return \c a_strlen(s) if less than \c n, else \c n.
 131  */
 132 static inline ssize_t a_strnlen(const char *s, ssize_t n)
 133 {
 134     if (s)
 135     {
 136         const char *p = memchr(s, '\0', n);
 137         return p ? p - s : n;
 138     }
 139     return 0;
 140 }
 141
 142 /** \brief \c NULL resistant strdup.
 143  *
 144  * the a_strdup() function returns a pointer to a new string, which is a
 145  * duplicate of \c s. Memory should be freed using p_delete().
 146  *
 147  * \warning when s is \c "", it returns NULL !
 148  *
 149  * \param[in] s the string to duplicate.
 150  * \return a pointer to the duplicated string.
 151  */
 152 static inline char *a_strdup(const char *s)
 153 {
 154     ssize_t len = a_strlen(s);
 155     return len ? p_dup(s, len + 1) : NULL;
 156 }
 157
 158 /** \brief \c NULL resistant strcmp.
 159  * \param[in]  a     the first string.
 160  * \param[in]  b     the second string.
 161  * \return <tt>strcmp(a, b)</tt>, and treats \c NULL strings like \c ""
 162  * ones.
 163  */
 164 static inline int a_strcmp(const char *a, const char *b)
 165 {
 166         return strcmp(NONULL(a), NONULL(b));
 167 }
 168
 169 /** \brief \c NULL resistant strncmp.
 170  * \param[in]  a     the first string.
 171  * \param[in]  b     the second string.
 172  * \param[in]  n     the number of maximum chars to compare.
 173  * \return <tt>strncmp(a, b, n)</tt>, and treats \c NULL strings like \c ""
 174  * ones.
 175  */
 176 static inline int a_strncmp(const char *a, const char *b, ssize_t n)
 177 {
 178     return strncmp(NONULL(a), NONULL(b), n);
 179 }
 180
 181 ssize_t a_strncpy(char *dst, ssize_t n, const char *src, ssize_t l) __attribute__((nonnull(1)));
 182 ssize_t a_strcpy(char *dst, ssize_t n, const char *src) __attribute__((nonnull(1)));
 183
 184 /** \brief safe strcat.
 185  *
 186  * The a_strcat() function appends the string \c src at the end of the buffer
 187  * \c dst if space is available.
 188  *
 189  * \param[in]  dst   destination buffer.
 190  * \param[in]  n     size of the buffer, Negative sizes are allowed.
 191  * \param[in]  src   the string to append.
 192  * \return <tt>a_strlen(dst) + a_strlen(src)</tt>
 193  */
 194 static inline ssize_t a_strcat(char *dst, ssize_t n, const char *src)
 195 {
 196     ssize_t dlen = a_strnlen(dst, n - 1);
 197     return dlen + a_strcpy(dst + dlen, n - dlen, src);
 198 }
 199
 200 /** \brief safe strncat.
 201  *
 202  * The m_strncat() function appends at most \c n chars from the string \c src
 203  * at the end of the buffer \c dst if space is available.
 204  *
 205  * \param[in]  dst   destination buffer.
 206  * \param[in]  n     size of the buffer, Negative sizes are allowed.
 207  * \param[in]  src   the string to append.
 208  * \param[in]  l     maximum number of chars of src to consider.
 209  * \return the smallest value between <tt>m_strlen(dst) + m_strlen(src)</tt>
 210  * and <tt>m_strlen(dst) + l</tt>
 211  */
 212 static inline ssize_t
 213 a_strncat(char *dst, ssize_t n, const char *src, ssize_t l)
 214 {
 215     ssize_t dlen = a_strnlen(dst, n - 1);
 216     return dlen + a_strncpy(dst + dlen, n - dlen, src, l);
 217 }
 218
 219 void die(const char *, ...) __attribute__ ((noreturn)) __attribute__ ((format(printf, 1, 2)));
 220 void eprint(const char *, ...) __attribute__ ((noreturn)) __attribute__ ((format(printf, 1, 2)));
 221 double compute_new_value_from_arg(const char *, double);
 222 void warn(const char *, ...) __attribute__ ((format(printf, 1, 2)));
 223 void *name_func_lookup(const char *, const name_func_link_t *);
 224
 225 #endif
 226 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80