Remove the exception for tizen common in .spec file

[platform/upstream/libxkbcommon.git] / src / utils.h

diff --git a/src/utils.h b/src/utils.h
index acd191e..aa7969c 100644 (file)
--- a/src/utils.h
+++ b/src/utils.h
@@ -26,9 +26,27 @@
 
 #include <errno.h>
 #include <inttypes.h>
+#include <stdarg.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#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 <direct.h>
+# include <io.h>
+# ifndef S_ISDIR
+#  define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
+# endif
+#endif
 
 #include "darray.h"
 
@@ -36,6 +54,26 @@
     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);
 
@@ -48,10 +86,19 @@ 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)
@@ -119,7 +166,7 @@ strndup(const char *s, size_t n)
     char *p = malloc(len + 1);
     if (!p)
         return NULL;
-    memcpy(p, str, len);
+    memcpy(p, s, len);
     p[len] = '\0';
     return p;
 }
@@ -194,13 +241,19 @@ map_file(FILE *file, char **string_out, size_t *size_out);
 void
 unmap_file(char *string, size_t size);
 
-#define ARRAY_SIZE(arr) ((sizeof(arr) / sizeof(*(arr))))
-
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
-#define MAX(a, b) ((a) > (b) ? (a) : (b))
+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
 
-/* Round up @a so it's divisible by @b. */
-#define ROUNDUP(a, b) (((a) + (b) - 1) / (b) * (b))
+    return true;
+}
 
 #if defined(HAVE_SECURE_GETENV)
 # define secure_getenv secure_getenv
@@ -228,7 +281,9 @@ unmap_file(char *string, size_t size);
 # 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)
@@ -267,4 +322,50 @@ 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 */