2 * util.h - useful functions header
4 * Copyright © 2007-2008 Julien Danjou <julien@danjou.info>
5 * Copyright © 2006 Pierre Habouzit <madcoder@debian.org>
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.
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.
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.
23 #ifndef AWESOME_COMMON_UTIL_H
24 #define AWESOME_COMMON_UTIL_H
32 #if !(defined (__FreeBSD__) || defined(__OpenBSD__))
45 /** A list of possible position, not sex related */
55 /** Link a name to a function */
62 /** \brief replace \c NULL strings with emtpy strings */
63 #define NONULL(x) (x ? x : "")
65 #define DO_NOTHING(...)
69 #define MAX(a,b) ((a) < (b) ? (b) : (a))
70 #define MIN(a,b) ((a) < (b) ? (a) : (b))
72 #define ssizeof(foo) (ssize_t)sizeof(foo)
73 #define countof(foo) (ssizeof(foo) / ssizeof(foo[0]))
75 #define p_alloca(type, count) \
76 ((type *)memset(alloca(sizeof(type) * (count)), \
77 0, sizeof(type) * (count)))
79 #define p_alloc_nr(x) (((x) + 16) * 3 / 2)
80 #define p_new(type, count) ((type *)xmalloc(sizeof(type) * (count)))
81 #define p_clear(p, count) ((void)memset((p), 0, sizeof(*(p)) * (count)))
82 #define p_realloc(pp, count) xrealloc((void*)(pp), sizeof(**(pp)) * (count))
83 #define p_dup(p, count) xmemdup((p), sizeof(*(p)) * (count))
84 #define p_grow(pp, goalnb, allocnb) \
86 if ((goalnb) > *(allocnb)) { \
87 if (p_alloc_nr(*(allocnb)) < (goalnb)) { \
88 *(allocnb) = (goalnb); \
90 *(allocnb) = p_alloc_nr(*(allocnb)); \
92 p_realloc(pp, *(allocnb)); \
99 #define p_delete(mem_pp) \
101 typeof(**(mem_pp)) **__ptr = (mem_pp); \
106 #define likely(expr) __builtin_expect(!!(expr), 1)
107 #define unlikely(expr) __builtin_expect((expr), 0)
111 #define p_delete(mem_p) \
113 void *__ptr = (mem_p); \
115 *(void **)__ptr = NULL; \
118 #define likely(expr) expr
119 #define unlikely(expr) expr
123 static inline void * __attribute__ ((malloc
)) xmalloc(ssize_t size
)
130 ptr
= calloc(1, size
);
139 xrealloc(void **ptr
, ssize_t newsize
)
145 *ptr
= realloc(*ptr
, newsize
);
151 /** Duplicate a memory zone.
152 * \param src The source.
153 * \param size The source size.
154 * \return The memory address of the copy.
156 static inline void *xmemdup(const void *src
, ssize_t size
)
158 return memcpy(xmalloc(size
), src
, size
);
161 /** \brief \c NULL resistant strlen.
163 * Unlike it's libc sibling, a_strlen returns a ssize_t, and supports its
164 * argument being NULL.
166 * \param[in] s the string.
167 * \return the string length (or 0 if \c s is \c NULL).
169 static inline ssize_t
a_strlen(const char *s
)
171 return s
? strlen(s
) : 0;
174 /** \brief \c NULL resistant strnlen.
176 * Unlike it's GNU libc sibling, a_strnlen returns a ssize_t, and supports
177 * its argument being NULL.
179 * The a_strnlen() function returns the number of characters in the string
180 * pointed to by \c s, not including the terminating \c \\0 character, but at
181 * most \c n. In doing this, a_strnlen() looks only at the first \c n
182 * characters at \c s and never beyond \c s+n.
184 * \param[in] s the string.
185 * \param[in] n the maximum length to return.
186 * \return \c a_strlen(s) if less than \c n, else \c n.
188 static inline ssize_t
a_strnlen(const char *s
, ssize_t n
)
192 const char *p
= memchr(s
, '\0', n
);
193 return p
? p
- s
: n
;
198 /** \brief \c NULL resistant strdup.
200 * the a_strdup() function returns a pointer to a new string, which is a
201 * duplicate of \c s. Memory should be freed using p_delete().
203 * \warning when s is \c "", it returns NULL !
205 * \param[in] s the string to duplicate.
206 * \return a pointer to the duplicated string.
209 char *a_strdup(const char *s
)
211 ssize_t len
= a_strlen(s
);
212 return len
? p_dup(s
, len
+ 1) : NULL
;
215 /** \brief safe limited strdup.
217 * Copies at most min(<tt>n-1</tt>, \c l) characters from \c src into a newly
218 * allocated buffer, always adding a final \c \\0, and returns that buffer.
220 * \warning when s is \c "" or l is 0, it returns NULL !
222 * \param[in] s source string.
223 * \param[in] l maximum number of chars to copy.
224 * \return a newly allocated buffer containing the first \c l chars of \c src.
227 char * a_strndup(const char *s
, ssize_t l
)
229 ssize_t len
= MIN(a_strlen(s
), l
);
232 char *p
= p_dup(s
, len
+ 1);
239 /** \brief \c NULL resistant strcmp.
240 * \param[in] a the first string.
241 * \param[in] b the second string.
242 * \return <tt>strcmp(a, b)</tt>, and treats \c NULL strings like \c ""
245 static inline int a_strcmp(const char *a
, const char *b
)
247 return strcmp(NONULL(a
), NONULL(b
));
250 /** \brief \c NULL resistant strcasecmp.
251 * \param[in] a the first string.
252 * \param[in] b the second string.
253 * \return <tt>strcasecmp(a, b)</tt>, and treats \c NULL strings like \c ""
256 static inline int a_strcasecmp(const char *a
, const char *b
)
258 return strcasecmp(NONULL(a
), NONULL(b
));
261 /** \brief \c NULL resistant strncmp.
262 * \param[in] a the first string.
263 * \param[in] b the second string.
264 * \param[in] n the number of maximum chars to compare.
265 * \return <tt>strncmp(a, b, n)</tt>, and treats \c NULL strings like \c ""
268 static inline int a_strncmp(const char *a
, const char *b
, ssize_t n
)
270 return strncmp(NONULL(a
), NONULL(b
), n
);
273 ssize_t
a_strncpy(char *dst
, ssize_t n
, const char *src
, ssize_t l
) __attribute__((nonnull(1)));
274 ssize_t
a_strcpy(char *dst
, ssize_t n
, const char *src
) __attribute__((nonnull(1)));
276 /** \brief safe strcat.
278 * The a_strcat() function appends the string \c src at the end of the buffer
279 * \c dst if space is available.
281 * \param[in] dst destination buffer.
282 * \param[in] n size of the buffer, Negative sizes are allowed.
283 * \param[in] src the string to append.
284 * \return <tt>a_strlen(dst) + a_strlen(src)</tt>
286 static inline ssize_t
a_strcat(char *dst
, ssize_t n
, const char *src
)
288 ssize_t dlen
= a_strnlen(dst
, n
- 1);
289 return dlen
+ a_strcpy(dst
+ dlen
, n
- dlen
, src
);
292 /** \brief safe strncat.
294 * The a_strncat() function appends at most \c n chars from the string \c src
295 * at the end of the buffer \c dst if space is available.
297 * \param[in] dst destination buffer.
298 * \param[in] n size of the buffer, Negative sizes are allowed.
299 * \param[in] src the string to append.
300 * \param[in] l maximum number of chars of src to consider.
301 * \return the smallest value between <tt>a_strlen(dst) + a_strlen(src)</tt>
302 * and <tt>a_strlen(dst) + l</tt>
304 static inline ssize_t
305 a_strncat(char *dst
, ssize_t n
, const char *src
, ssize_t l
)
307 ssize_t dlen
= a_strnlen(dst
, n
- 1);
308 return dlen
+ a_strncpy(dst
+ dlen
, n
- dlen
, src
, l
);
311 /** \brief convert a string to a boolean value.
313 * The a_strtobool() function converts a string \c s into a boolean.
314 * It recognizes the strings "true", "on", "yes" and "1".
316 * \param[in] s the string to convert
317 * \return true if the string is recognized as possibly true, false otherwise.
320 a_strtobool(const char *s
, ssize_t len
)
322 switch(a_tokenize(s
, len
))
334 #define fatal(string, ...) _fatal(__LINE__, \
336 string, ## __VA_ARGS__)
337 void _fatal(int, const char *, const char *, ...)
338 __attribute__ ((noreturn
)) __attribute__ ((format(printf
, 3, 4)));
340 #define warn(string, ...) _warn(__LINE__, \
342 string, ## __VA_ARGS__)
343 void _warn(int, const char *, const char *, ...)
344 __attribute__ ((format(printf
, 3, 4)));
346 position_t
position_fromstr(const char *, ssize_t
);
347 const char * position_tostr(position_t
);
348 orientation_t
orientation_fromstr(const char *, ssize_t
);
349 const char * orientation_tostr(orientation_t
);
350 void *name_func_lookup(const char *, const name_func_link_t
*);
351 const char * name_func_rlookup(void *, const name_func_link_t
*);
352 void a_exec(const char *);
353 char ** a_strsplit(const char *, ssize_t
, char);
356 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80