X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Futils.h;h=aa7969c12e9623fc9d0582dc665bd7cd6c28981e;hb=357c00b3a1c28afeb352887397ab9549740f1c85;hp=89e2c1380d0c6e69e5e5bab000e7eeabd87e9522;hpb=2c30fa7a6079e24fc9a7d05039bfae260cfc79a1;p=platform%2Fupstream%2Flibxkbcommon.git diff --git a/src/utils.h b/src/utils.h index 89e2c13..aa7969c 100644 --- a/src/utils.h +++ b/src/utils.h @@ -1,43 +1,275 @@ -#ifndef UTILS_H -#define UTILS_H 1 - -/*\ - * - * COPYRIGHT 1990 - * DIGITAL EQUIPMENT CORPORATION - * MAYNARD, MASSACHUSETTS - * ALL RIGHTS RESERVED. +/* + * Copyright © 2012 Ran Benita * - * THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE AND - * SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT CORPORATION. - * DIGITAL MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE - * FOR ANY PURPOSE. IT IS SUPPLIED "AS IS" WITHOUT EXPRESS OR IMPLIED - * WARRANTY. + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: * - * IF THE SOFTWARE IS MODIFIED IN A MANNER CREATING DERIVATIVE COPYRIGHT - * RIGHTS, APPROPRIATE LEGENDS MAY BE PLACED ON THE DERIVATIVE WORK IN - * ADDITION TO THAT SET FORTH ABOVE. + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. * - * Permission to use, copy, modify, and distribute this software and its - * documentation for any purpose and without fee is hereby granted, provided - * that the above copyright notice appear in all copies and that both that - * copyright notice and this permission notice appear in supporting - * documentation, and that the name of Digital Equipment Corporation not be - * used in advertising or publicity pertaining to distribution of the - * software without specific, written prior permission. - \*/ + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#ifndef UTILS_H +#define UTILS_H 1 + +#include +#include +#include +#include +#include +#include +#if HAVE_UNISTD_H +# include +#else +/* Required on Windows where unistd.h doesn't exist */ +# define R_OK 4 /* Test for read permission. */ +# define W_OK 2 /* Test for write permission. */ +# define X_OK 1 /* Test for execute permission. */ +# define F_OK 0 /* Test for existence. */ +#endif + +#ifdef _WIN32 +# include +# include +# ifndef S_ISDIR +# define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR) +# endif +#endif + +#include "darray.h" + +#define STATIC_ASSERT(expr, message) do { \ + switch (0) { case 0: case (expr): ; } \ +} while (0) + +#define ARRAY_SIZE(arr) ((sizeof(arr) / sizeof(*(arr)))) + +#define MIN(a, b) ((a) < (b) ? (a) : (b)) +#define MAX(a, b) ((a) > (b) ? (a) : (b)) + +/* Round up @a so it's divisible by @b. */ +#define ROUNDUP(a, b) (((a) + (b) - 1) / (b) * (b)) + +#define STRINGIFY(x) #x +#define STRINGIFY2(x) STRINGIFY(x) + +/* Check if a character is valid in a string literal */ +static inline bool +is_valid_char(char c) +{ + /* Currently we only check for NULL character, but this could be extended + * in the future to further ASCII control characters. */ + return c != 0; +} + +char +to_lower(char c); + +int +istrcmp(const char *a, const char *b); + +int +istrncmp(const char *a, const char *b, size_t n); + +static inline bool +streq(const char *s1, const char *s2) +{ + assert(s1 && s2); + return strcmp(s1, s2) == 0; +} + +static inline bool +streq_null(const char *s1, const char *s2) +{ + if (s1 == NULL || s2 == NULL) + return s1 == s2; + return streq(s1, s2); +} + +static inline bool +streq_not_null(const char *s1, const char *s2) +{ + if (!s1 || !s2) + return false; + return streq(s1, s2); +} + +static inline bool +istreq(const char *s1, const char *s2) +{ + return istrcmp(s1, s2) == 0; +} + +static inline bool +istreq_prefix(const char *s1, const char *s2) +{ + return istrncmp(s1, s2, strlen(s1)) == 0; +} + +static inline char * +strdup_safe(const char *s) +{ + return s ? strdup(s) : NULL; +} + +static inline size_t +strlen_safe(const char *s) +{ + return s ? strlen(s) : 0; +} + +static inline bool +isempty(const char *s) +{ + return s == NULL || s[0] == '\0'; +} + +static inline const char * +strnull(const char *s) +{ + return s ? s : "(null)"; +} + +static inline const char * +strempty(const char *s) +{ + return s ? s : ""; +} + +static inline void * +memdup(const void *mem, size_t nmemb, size_t size) +{ + void *p = calloc(nmemb, size); + if (p) + memcpy(p, mem, nmemb * size); + return p; +} -/***====================================================================***/ +#if !(defined(HAVE_STRNDUP) && HAVE_STRNDUP) +static inline char * +strndup(const char *s, size_t n) +{ + size_t slen = strlen(s); + size_t len = MIN(slen, n); + char *p = malloc(len + 1); + if (!p) + return NULL; + memcpy(p, s, len); + p[len] = '\0'; + return p; +} +#endif + +/* ctype.h is locale-dependent and has other oddities. */ +static inline bool +is_space(char ch) +{ + return ch == ' ' || (ch >= '\t' && ch <= '\r'); +} + +static inline bool +is_alpha(char ch) +{ + return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'); +} + +static inline bool +is_digit(char ch) +{ + return ch >= '0' && ch <= '9'; +} + +static inline bool +is_alnum(char ch) +{ + return is_alpha(ch) || is_digit(ch); +} + +static inline bool +is_xdigit(char ch) +{ + return + (ch >= '0' && ch <= '9') || + (ch >= 'a' && ch <= 'f') || + (ch >= 'A' && ch <= 'F'); +} + +static inline bool +is_graph(char ch) +{ + /* See table in ascii(7). */ + return ch >= '!' && ch <= '~'; +} /* - * We sometimes malloc strings and then expose them as const char*'s. This - * macro is used when we free these strings in order to avoid -Wcast-qual - * errors. + * Return the bit position of the most significant bit. + * Note: this is 1-based! It's more useful this way, and returns 0 when + * mask is all 0s. */ -#define UNCONSTIFY(const_ptr) ((void *) (uintptr_t) (const_ptr)) +static inline unsigned +msb_pos(uint32_t mask) +{ + unsigned pos = 0; + while (mask) { + pos++; + mask >>= 1u; + } + return pos; +} + +static inline int +one_bit_set(uint32_t x) +{ + return x && (x & (x - 1)) == 0; +} + +bool +map_file(FILE *file, char **string_out, size_t *size_out); -#define uDupString(s) ((s) ? strdup(s) : NULL) -#define uStrCasePrefix(s1, s2) (strncasecmp((s1), (s2), strlen(s1)) == 0) +void +unmap_file(char *string, size_t size); + +static inline bool +check_eaccess(const char *path, int mode) +{ +#if defined(HAVE_EACCESS) + if (eaccess(path, mode) != 0) + return false; +#elif defined(HAVE_EUIDACCESS) + if (euidaccess(path, mode) != 0) + return false; +#endif + + return true; +} + +#if defined(HAVE_SECURE_GETENV) +# define secure_getenv secure_getenv +#elif defined(HAVE___SECURE_GETENV) +# define secure_getenv __secure_getenv +#else +# define secure_getenv getenv +#endif + +#if defined(HAVE___BUILTIN_EXPECT) +# define likely(x) __builtin_expect(!!(x), 1) +# define unlikely(x) __builtin_expect(!!(x), 0) +#else +# define likely(x) (x) +# define unlikely(x) (x) +#endif /* Compiler Attributes */ @@ -49,7 +281,9 @@ # define XKB_EXPORT #endif -#if defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 203) +#if defined(__MINGW32__) +# define ATTR_PRINTF(x,y) __attribute__((__format__(__MINGW_PRINTF_FORMAT, x, y))) +#elif defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 203) # define ATTR_PRINTF(x,y) __attribute__((__format__(__printf__, x, y))) #else /* not gcc >= 2.3 */ # define ATTR_PRINTF(x,y) @@ -68,4 +302,70 @@ #define ATTR_MALLOC #endif +#if defined(__GNUC__) && (__GNUC__ >= 4) +# define ATTR_NULL_SENTINEL __attribute__((__sentinel__)) +#else +# define ATTR_NULL_SENTINEL +#endif /* GNUC >= 4 */ + +#if (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 295) +#define ATTR_PACKED __attribute__((__packed__)) +#else +#define ATTR_PACKED +#endif + +#if !(defined(HAVE_ASPRINTF) && HAVE_ASPRINTF) +int asprintf(char **strp, const char *fmt, ...) ATTR_PRINTF(2, 3); +# if !(defined(HAVE_VASPRINTF) && HAVE_VASPRINTF) +# include +int vasprintf(char **strp, const char *fmt, va_list ap); +# endif /* !HAVE_VASPRINTF */ +#endif /* !HAVE_ASPRINTF */ + +static inline bool +ATTR_PRINTF(3, 4) +snprintf_safe(char *buf, size_t sz, const char *format, ...) +{ + va_list ap; + int rc; + + va_start(ap, format); + rc = vsnprintf(buf, sz, format, ap); + va_end(ap); + + return rc >= 0 && (size_t)rc < sz; +} + +static inline char * +ATTR_PRINTF(1, 0) +vasprintf_safe(const char *fmt, va_list args) +{ + char *str; + int len; + + len = vasprintf(&str, fmt, args); + + if (len == -1) + return NULL; + + return str; +} + +/** + * A version of asprintf that returns the allocated string or NULL on error. + */ +static inline char * +ATTR_PRINTF(1, 2) +asprintf_safe(const char *fmt, ...) +{ + va_list args; + char *str; + + va_start(args, fmt); + str = vasprintf_safe(fmt, args); + va_end(args); + + return str; +} + #endif /* UTILS_H */