#include <stdbool.h>
#include <stdio.h>
#include <string.h>
-#include <strings.h>
#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)
+
+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)
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 *
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 ? 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 = malloc(nmemb * 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, const char **string_out, size_t *size_out);
+map_file(FILE *file, char **string_out, size_t *size_out);
void
-unmap_file(const char *str, size_t size);
+unmap_file(char *string, size_t size);
#define ARRAY_SIZE(arr) ((sizeof(arr) / sizeof(*(arr))))
#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))
+
+/* Round up @a so it's divisible by @b. */
+#define ROUNDUP(a, b) (((a) + (b) - 1) / (b) * (b))
+
+#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 */
# 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 <stdarg.h>
+int vasprintf(char **strp, const char *fmt, va_list ap);
+# endif /* !HAVE_VASPRINTF */
+#endif /* !HAVE_ASPRINTF */
+
#endif /* UTILS_H */