+
+BT_HIDDEN
+void bt_common_normalize_star_glob_pattern(char *pattern)
+{
+ const char *p;
+ char *np;
+ bool got_star = false;
+
+ BT_ASSERT(pattern);
+
+ for (p = pattern, np = pattern; *p != '\0'; p++) {
+ switch (*p) {
+ case '*':
+ if (got_star) {
+ /* Avoid consecutive stars. */
+ continue;
+ }
+
+ got_star = true;
+ break;
+ case '\\':
+ /* Copy backslash character. */
+ *np = *p;
+ np++;
+ p++;
+
+ if (*p == '\0') {
+ goto end;
+ }
+
+ /* Fall through default case. */
+ default:
+ got_star = false;
+ break;
+ }
+
+ /* Copy single character. */
+ *np = *p;
+ np++;
+ }
+
+end:
+ *np = '\0';
+}
+
+static inline
+bool at_end_of_pattern(const char *p, const char *pattern, size_t pattern_len)
+{
+ return (p - pattern) == pattern_len || *p == '\0';
+}
+
+/*
+ * Globbing matching function with the star feature only (`?` and
+ * character sets are not supported). This matches `candidate` (plain
+ * string) against `pattern`. A literal star can be escaped with `\` in
+ * `pattern`.
+ *
+ * `pattern_len` or `candidate_len` can be greater than the actual
+ * string length of `pattern` or `candidate` if the string is
+ * null-terminated.
+ */
+BT_HIDDEN
+bool bt_common_star_glob_match(const char *pattern, size_t pattern_len,
+ const char *candidate, size_t candidate_len) {
+ const char *retry_c = candidate, *retry_p = pattern, *c, *p;
+ bool got_a_star = false;
+
+retry:
+ c = retry_c;
+ p = retry_p;
+
+ /*
+ * The concept here is to retry a match in the specific case
+ * where we already got a star. The retry position for the
+ * pattern is just after the most recent star, and the retry
+ * position for the candidate is the character following the
+ * last try's first character.
+ *
+ * Example:
+ *
+ * candidate: hi ev every onyx one
+ * ^
+ * pattern: hi*every*one
+ * ^
+ *
+ * candidate: hi ev every onyx one
+ * ^
+ * pattern: hi*every*one
+ * ^
+ *
+ * candidate: hi ev every onyx one
+ * ^
+ * pattern: hi*every*one
+ * ^
+ *
+ * candidate: hi ev every onyx one
+ * ^
+ * pattern: hi*every*one
+ * ^ MISMATCH
+ *
+ * candidate: hi ev every onyx one
+ * ^
+ * pattern: hi*every*one
+ * ^
+ *
+ * candidate: hi ev every onyx one
+ * ^^
+ * pattern: hi*every*one
+ * ^^
+ *
+ * candidate: hi ev every onyx one
+ * ^ ^
+ * pattern: hi*every*one
+ * ^ ^ MISMATCH
+ *
+ * candidate: hi ev every onyx one
+ * ^
+ * pattern: hi*every*one
+ * ^ MISMATCH
+ *
+ * candidate: hi ev every onyx one
+ * ^
+ * pattern: hi*every*one
+ * ^ MISMATCH
+ *
+ * candidate: hi ev every onyx one
+ * ^
+ * pattern: hi*every*one
+ * ^
+ *
+ * candidate: hi ev every onyx one
+ * ^^
+ * pattern: hi*every*one
+ * ^^
+ *
+ * candidate: hi ev every onyx one
+ * ^ ^
+ * pattern: hi*every*one
+ * ^ ^
+ *
+ * candidate: hi ev every onyx one
+ * ^ ^
+ * pattern: hi*every*one
+ * ^ ^
+ *
+ * candidate: hi ev every onyx one
+ * ^ ^
+ * pattern: hi*every*one
+ * ^ ^
+ *
+ * candidate: hi ev every onyx one
+ * ^
+ * pattern: hi*every*one
+ * ^
+ *
+ * candidate: hi ev every onyx one
+ * ^
+ * pattern: hi*every*one
+ * ^ MISMATCH
+ *
+ * candidate: hi ev every onyx one
+ * ^
+ * pattern: hi*every*one
+ * ^
+ *
+ * candidate: hi ev every onyx one
+ * ^^
+ * pattern: hi*every*one
+ * ^^
+ *
+ * candidate: hi ev every onyx one
+ * ^ ^
+ * pattern: hi*every*one
+ * ^ ^ MISMATCH
+ *
+ * candidate: hi ev every onyx one
+ * ^
+ * pattern: hi*every*one
+ * ^ MISMATCH
+ *
+ * candidate: hi ev every onyx one
+ * ^
+ * pattern: hi*every*one
+ * ^ MISMATCH
+ *
+ * candidate: hi ev every onyx one
+ * ^
+ * pattern: hi*every*one
+ * ^ MISMATCH
+ *
+ * candidate: hi ev every onyx one
+ * ^
+ * pattern: hi*every*one
+ * ^ MISMATCH
+ *
+ * candidate: hi ev every onyx one
+ * ^
+ * pattern: hi*every*one
+ * ^
+ *
+ * candidate: hi ev every onyx one
+ * ^^
+ * pattern: hi*every*one
+ * ^^
+ *
+ * candidate: hi ev every onyx one
+ * ^ ^
+ * pattern: hi*every*one
+ * ^ ^
+ *
+ * candidate: hi ev every onyx one
+ * ^ ^
+ * pattern: hi*every*one
+ * ^ ^ SUCCESS
+ */
+ while ((c - candidate) < candidate_len && *c != '\0') {
+ BT_ASSERT(*c);
+
+ if (at_end_of_pattern(p, pattern, pattern_len)) {
+ goto end_of_pattern;
+ }
+
+ switch (*p) {
+ case '*':
+ got_a_star = true;
+
+ /*
+ * Our first try starts at the current candidate
+ * character and after the star in the pattern.
+ */
+ retry_c = c;
+ retry_p = p + 1;
+
+ if (at_end_of_pattern(retry_p, pattern, pattern_len)) {
+ /*
+ * Star at the end of the pattern at
+ * this point: automatic match.
+ */
+ return true;
+ }
+
+ goto retry;
+ case '\\':
+ /* Go to escaped character. */
+ p++;
+
+ /*
+ * Fall through the default case which compares
+ * the escaped character now.
+ */
+ default:
+ if (at_end_of_pattern(p, pattern, pattern_len) ||
+ *c != *p) {
+end_of_pattern:
+ /* Character mismatch OR end of pattern. */
+ if (!got_a_star) {
+ /*
+ * We didn't get any star yet,
+ * so this first mismatch
+ * automatically makes the whole
+ * test fail.
+ */
+ return false;
+ }
+
+ /*
+ * Next try: next candidate character,
+ * original pattern character (following
+ * the most recent star).
+ */
+ retry_c++;
+ goto retry;
+ }
+ break;
+ }
+
+ /* Next pattern and candidate characters. */
+ c++;
+ p++;
+ }
+
+ /*
+ * We checked every candidate character and we're still in a
+ * success state: the only pattern character allowed to remain
+ * is a star.
+ */
+ if (at_end_of_pattern(p, pattern, pattern_len)) {
+ return true;
+ }
+
+ p++;
+ return p[-1] == '*' && at_end_of_pattern(p, pattern, pattern_len);
+}
+
+static
+void append_path_parts(const char *path, GPtrArray *parts)
+{
+ const char *ch = path;
+ const char *last = path;
+
+ while (true) {
+ if (*ch == G_DIR_SEPARATOR || *ch == '\0') {
+ if (ch - last > 0) {
+ GString *part = g_string_new(NULL);
+
+ BT_ASSERT(part);
+ g_string_append_len(part, last, ch - last);
+ g_ptr_array_add(parts, part);
+ }
+
+ if (*ch == '\0') {
+ break;
+ }
+
+ last = ch + 1;
+ }
+
+ ch++;
+ }
+}
+
+static
+void destroy_gstring(void *gstring)
+{
+ (void) g_string_free(gstring, TRUE);
+}
+
+#ifdef __MINGW32__
+BT_HIDDEN
+GString *bt_common_normalize_path(const char *path, const char *wd)
+{
+ char *tmp;
+ GString *norm_path = NULL;
+
+ BT_ASSERT(path);
+
+ tmp = _fullpath(NULL, path, PATH_MAX);
+ if (!tmp) {
+ goto error;
+ }
+
+ norm_path = g_string_new(tmp);
+ if (!norm_path) {
+ goto error;
+ }
+
+ goto end;
+error:
+ if (norm_path) {
+ g_string_free(norm_path, TRUE);
+ norm_path = NULL;
+ }
+end:
+ if (tmp) {
+ free(tmp);
+ }
+ return norm_path;
+}
+#else
+BT_HIDDEN
+GString *bt_common_normalize_path(const char *path, const char *wd)
+{
+ size_t i;
+ GString *norm_path;
+ GPtrArray *parts = NULL;
+
+ BT_ASSERT(path);
+ norm_path = g_string_new(G_DIR_SEPARATOR_S);
+ if (!norm_path) {
+ goto error;
+ }
+
+ parts = g_ptr_array_new_with_free_func(destroy_gstring);
+ if (!parts) {
+ goto error;
+ }
+
+ if (path[0] != G_DIR_SEPARATOR) {
+ /* Relative path: start with working directory */
+ if (wd) {
+ append_path_parts(wd, parts);
+ } else {
+ gchar *cd = g_get_current_dir();
+
+ append_path_parts(cd, parts);
+ g_free(cd);
+ }
+ }
+
+ /* Append parts of the path parameter */
+ append_path_parts(path, parts);
+
+ /* Resolve special `..` and `.` parts */
+ for (i = 0; i < parts->len; i++) {
+ GString *part = g_ptr_array_index(parts, i);
+
+ if (strcmp(part->str, "..") == 0) {
+ if (i == 0) {
+ /*
+ * First part of absolute path is `..`:
+ * this is invalid.
+ */
+ goto error;
+ }
+
+ /* Remove `..` and previous part */
+ g_ptr_array_remove_index(parts, i - 1);
+ g_ptr_array_remove_index(parts, i - 1);
+ i -= 2;
+ } else if (strcmp(part->str, ".") == 0) {
+ /* Remove `.` */
+ g_ptr_array_remove_index(parts, i);
+ i -= 1;
+ }
+ }
+
+ /* Create normalized path with what's left */
+ for (i = 0; i < parts->len; i++) {
+ GString *part = g_ptr_array_index(parts, i);
+
+ g_string_append(norm_path, part->str);
+
+ if (i < parts->len - 1) {
+ g_string_append_c(norm_path, G_DIR_SEPARATOR);
+ }
+ }
+
+ goto end;
+
+error:
+ if (norm_path) {
+ g_string_free(norm_path, TRUE);
+ norm_path = NULL;
+ }
+
+end:
+ if (parts) {
+ g_ptr_array_free(parts, TRUE);
+ }
+
+ return norm_path;
+}
+#endif
+
+BT_HIDDEN
+size_t bt_common_get_page_size(void)
+{
+ int page_size;
+
+ page_size = bt_sysconf(_SC_PAGESIZE);
+ if (page_size < 0) {
+ BT_LOGF("Cannot get system's page size: ret=%d",
+ page_size);
+ abort();
+ }
+
+ return page_size;
+}
+
+#define BUF_STD_APPEND(...) \
+ do { \
+ char _tmp_fmt[64]; \
+ int _count; \
+ size_t _size = buf_size - (size_t) (*buf_ch - buf); \
+ size_t _tmp_fmt_size = (size_t) (fmt_ch - *out_fmt_ch); \
+ strncpy(_tmp_fmt, *out_fmt_ch, _tmp_fmt_size); \
+ _tmp_fmt[_tmp_fmt_size] = '\0'; \
+ _count = snprintf(*buf_ch, _size, _tmp_fmt, __VA_ARGS__); \
+ BT_ASSERT(_count >= 0); \
+ *buf_ch += MIN(_count, _size); \
+ } while (0)
+
+#define BUF_STD_APPEND_SINGLE_ARG(_type) \
+ do { \
+ _type _arg = va_arg(*args, _type); \
+ BUF_STD_APPEND(_arg); \
+ } while (0)
+
+static inline void handle_conversion_specifier_std(char *buf, char **buf_ch,
+ size_t buf_size, const char **out_fmt_ch, va_list *args)
+{
+ const char *fmt_ch = *out_fmt_ch;
+ enum LENGTH_MODIFIER {
+ LENGTH_MOD_H,
+ LENGTH_MOD_HH,
+ LENGTH_MOD_NONE,
+ LENGTH_MOD_LOW_L,
+ LENGTH_MOD_LOW_LL,
+ LENGTH_MOD_UP_L,
+ LENGTH_MOD_Z,
+ } length_mod = LENGTH_MOD_NONE;
+
+ /* skip '%' */
+ fmt_ch++;
+
+ if (*fmt_ch == '%') {
+ fmt_ch++;
+ **buf_ch = '%';
+ (*buf_ch)++;
+ goto update_rw_fmt;
+ }
+
+ /* flags */
+ for (;;) {
+ switch (*fmt_ch) {
+ case '-':
+ case '+':
+ case ' ':
+ case '#':
+ case '0':
+ case '\'':
+ fmt_ch++;
+ continue;
+ default:
+ break;
+ }
+ break;
+ }
+
+ /* width */
+ for (;;) {
+ if (*fmt_ch < '0' || *fmt_ch > '9') {
+ break;
+ }
+
+ fmt_ch++;
+ }
+
+ /* precision */
+ if (*fmt_ch == '.') {
+ fmt_ch++;
+
+ for (;;) {
+ if (*fmt_ch < '0' || *fmt_ch > '9') {
+ break;
+ }
+
+ fmt_ch++;
+ }
+ }
+
+ /* format (PRI*64) */
+ if (strncmp(fmt_ch, PRId64, sizeof(PRId64) - 1) == 0) {
+ fmt_ch += sizeof(PRId64) - 1;
+ BUF_STD_APPEND_SINGLE_ARG(int64_t);
+ goto update_rw_fmt;
+ } else if (strncmp(fmt_ch, PRIu64, sizeof(PRIu64) - 1) == 0) {
+ fmt_ch += sizeof(PRIu64) - 1;
+ BUF_STD_APPEND_SINGLE_ARG(uint64_t);
+ goto update_rw_fmt;
+ } else if (strncmp(fmt_ch, PRIx64, sizeof(PRIx64) - 1) == 0) {
+ fmt_ch += sizeof(PRIx64) - 1;
+ BUF_STD_APPEND_SINGLE_ARG(uint64_t);
+ goto update_rw_fmt;
+ } else if (strncmp(fmt_ch, PRIX64, sizeof(PRIX64) - 1) == 0) {
+ fmt_ch += sizeof(PRIX64) - 1;
+ BUF_STD_APPEND_SINGLE_ARG(uint64_t);
+ goto update_rw_fmt;
+ } else if (strncmp(fmt_ch, PRIo64, sizeof(PRIo64) - 1) == 0) {
+ fmt_ch += sizeof(PRIo64) - 1;
+ BUF_STD_APPEND_SINGLE_ARG(uint64_t);
+ goto update_rw_fmt;
+ } else if (strncmp(fmt_ch, PRIi64, sizeof(PRIi64) - 1) == 0) {
+ fmt_ch += sizeof(PRIi64) - 1;
+ BUF_STD_APPEND_SINGLE_ARG(int64_t);
+ goto update_rw_fmt;
+ }
+
+ // length modifier
+ switch (*fmt_ch) {
+ case 'h':
+ length_mod = LENGTH_MOD_H;
+ fmt_ch++;
+
+ if (*fmt_ch == 'h') {
+ length_mod = LENGTH_MOD_HH;
+ fmt_ch++;
+ break;
+ }
+ break;
+ case 'l':
+ length_mod = LENGTH_MOD_LOW_L;
+ fmt_ch++;
+
+ if (*fmt_ch == 'l') {
+ length_mod = LENGTH_MOD_LOW_LL;
+ fmt_ch++;
+ break;
+ }
+ break;
+ case 'L':
+ length_mod = LENGTH_MOD_UP_L;
+ fmt_ch++;
+ break;
+ case 'z':
+ length_mod = LENGTH_MOD_Z;
+ fmt_ch++;
+ break;
+ default:
+ break;
+ }
+
+ // format
+ switch (*fmt_ch) {
+ case 'c':
+ {
+ fmt_ch++;
+
+ switch (length_mod) {
+ case LENGTH_MOD_NONE:
+ BUF_STD_APPEND_SINGLE_ARG(int);
+ break;
+ case LENGTH_MOD_LOW_L:
+ BUF_STD_APPEND_SINGLE_ARG(wint_t);
+ break;
+ default:
+ abort();
+ }
+ break;
+ }
+ case 's':
+ fmt_ch++;
+
+ switch (length_mod) {
+ case LENGTH_MOD_NONE:
+ BUF_STD_APPEND_SINGLE_ARG(char *);
+ break;
+ case LENGTH_MOD_LOW_L:
+ BUF_STD_APPEND_SINGLE_ARG(wchar_t *);
+ break;
+ default:
+ abort();
+ }
+ break;
+ case 'd':
+ case 'i':
+ fmt_ch++;
+
+ switch (length_mod) {
+ case LENGTH_MOD_NONE:
+ case LENGTH_MOD_H:
+ case LENGTH_MOD_HH:
+ BUF_STD_APPEND_SINGLE_ARG(int);
+ break;
+ case LENGTH_MOD_LOW_L:
+ BUF_STD_APPEND_SINGLE_ARG(long);
+ break;
+ case LENGTH_MOD_LOW_LL:
+ BUF_STD_APPEND_SINGLE_ARG(long long);
+ break;
+ case LENGTH_MOD_Z:
+ BUF_STD_APPEND_SINGLE_ARG(size_t);
+ break;
+ default:
+ abort();
+ }
+ break;
+ case 'o':
+ case 'x':
+ case 'X':
+ case 'u':
+ fmt_ch++;
+
+ switch (length_mod) {
+ case LENGTH_MOD_NONE:
+ case LENGTH_MOD_H:
+ case LENGTH_MOD_HH:
+ BUF_STD_APPEND_SINGLE_ARG(unsigned int);
+ break;
+ case LENGTH_MOD_LOW_L:
+ BUF_STD_APPEND_SINGLE_ARG(unsigned long);
+ break;
+ case LENGTH_MOD_LOW_LL:
+ BUF_STD_APPEND_SINGLE_ARG(unsigned long long);
+ break;
+ case LENGTH_MOD_Z:
+ BUF_STD_APPEND_SINGLE_ARG(size_t);
+ break;
+ default:
+ abort();
+ }
+ break;
+ case 'f':
+ case 'F':
+ case 'e':
+ case 'E':
+ case 'g':
+ case 'G':
+ fmt_ch++;
+
+ switch (length_mod) {
+ case LENGTH_MOD_NONE:
+ BUF_STD_APPEND_SINGLE_ARG(double);
+ break;
+ case LENGTH_MOD_UP_L:
+ BUF_STD_APPEND_SINGLE_ARG(long double);
+ break;
+ default:
+ abort();
+ }
+ break;
+ case 'p':
+ fmt_ch++;
+
+ if (length_mod == LENGTH_MOD_NONE) {
+ BUF_STD_APPEND_SINGLE_ARG(void *);
+ } else {
+ abort();
+ }
+ break;
+ default:
+ abort();
+ }
+
+update_rw_fmt:
+ *out_fmt_ch = fmt_ch;
+}
+
+BT_HIDDEN
+void bt_common_custom_vsnprintf(char *buf, size_t buf_size,
+ char intro,
+ bt_common_handle_custom_specifier_func handle_specifier,
+ void *priv_data, const char *fmt, va_list *args)
+{
+ const char *fmt_ch = fmt;
+ char *buf_ch = buf;
+
+ BT_ASSERT(buf);
+ BT_ASSERT(fmt);
+ BT_ASSERT(*args);
+
+ while (*fmt_ch != '\0') {
+ switch (*fmt_ch) {
+ case '%':
+ BT_ASSERT(fmt_ch[1] != '\0');
+
+ if (fmt_ch[1] == intro) {
+ handle_specifier(priv_data, &buf_ch,
+ buf_size - (size_t) (buf_ch - buf),
+ &fmt_ch, args);
+ } else {
+ handle_conversion_specifier_std(buf, &buf_ch,
+ buf_size, &fmt_ch, args);
+ }
+
+ if (buf_ch >= buf + buf_size - 1) {
+ fmt_ch = "";
+ }
+ break;
+ default:
+ *buf_ch = *fmt_ch;
+ buf_ch++;
+ if (buf_ch >= buf + buf_size - 1) {
+ fmt_ch = "";
+ }
+
+ fmt_ch++;
+ }
+ }
+
+ *buf_ch = '\0';
+}
+
+BT_HIDDEN
+void bt_common_custom_snprintf(char *buf, size_t buf_size,
+ char intro,
+ bt_common_handle_custom_specifier_func handle_specifier,
+ void *priv_data, const char *fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ bt_common_custom_vsnprintf(buf, buf_size, intro, handle_specifier,
+ priv_data, fmt, &args);
+ va_end(args);
+}