X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Futils.h;h=aa7969c12e9623fc9d0582dc665bd7cd6c28981e;hb=bb3a6894d5521a9cbf9be2ec0012cf6b861537e2;hp=9f0505ce40e183e2b513673cde1c32761a56fd9c;hpb=b21107056e0540489669bb35fcb3abe1b5b46ecd;p=platform%2Fupstream%2Flibxkbcommon.git diff --git a/src/utils.h b/src/utils.h index 9f0505c..aa7969c 100644 --- a/src/utils.h +++ b/src/utils.h @@ -24,27 +24,81 @@ #ifndef UTILS_H #define UTILS_H 1 +#include #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" -/* - * 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. - */ -#define UNCONSTIFY(const_ptr) ((void *) (uintptr_t) (const_ptr)) +#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) @@ -55,13 +109,13 @@ streq_not_null(const char *s1, const char *s2) static inline bool istreq(const char *s1, const char *s2) { - return strcasecmp(s1, s2) == 0; + return istrcmp(s1, s2) == 0; } static inline bool istreq_prefix(const char *s1, const char *s2) { - return strncasecmp(s1, s2, strlen(s1)) == 0; + return istrncmp(s1, s2, strlen(s1)) == 0; } static inline char * @@ -70,6 +124,12 @@ 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) { @@ -82,10 +142,134 @@ strnull(const char *s) return s ? s : "(null)"; } -#define MIN(a, b) ((a) < (b) ? (a) : (b)) -#define MIN3(a, b, c) MIN(MIN((a), (b)), (c)) -#define MAX(a, b) ((a) > (b) ? (a) : (b)) -#define MAX3(a, b, c) MAX(MAX((a), (b)), (c)) +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 <= '~'; +} + +/* + * 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. + */ +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); + +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 */ @@ -97,7 +281,9 @@ strnull(const char *s) # 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) @@ -122,4 +308,64 @@ strnull(const char *s) # 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 */