1 files changed, 787 insertions, 0 deletions

diff --git a/src/contrib/tinydir-1.2.4/tinydir.h b/src/contrib/tinydir-1.2.4/tinydir.h
new file mode 100644
index 0000000..89be46f
--- /dev/null
+++ b/src/contrib/tinydir-1.2.4/tinydir.h
@@ -0,0 +1,787 @@
+/*
+Copyright (c) 2013-2021, tinydir authors:
+- Cong Xu
+- Lautis Sun
+- Baudouin Feildel
+- Andargor <andargor@yahoo.com>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+                                                               modification, are
+permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+                                                                              2.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+           THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+            */
+#ifndef TINYDIR_H
+#define TINYDIR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if ((defined _UNICODE) && !(defined UNICODE))
+#define UNICODE
+#endif
+
+#if ((defined UNICODE) && !(defined _UNICODE))
+#define _UNICODE
+#endif
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef _MSC_VER
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <tchar.h>
+#include <windows.h>
+#pragma warning(push)
+#pragma warning(disable : 4996)
+#else
+#include <dirent.h>
+#include <libgen.h>
+#include <stddef.h>
+#include <sys/stat.h>
+#endif
+#ifdef __MINGW32__
+#include <tchar.h>
+#endif
+
+/* types */
+
+/* Windows UNICODE wide character support */
+#if defined _MSC_VER || defined __MINGW32__
+#define _tinydir_char_t   TCHAR
+#define TINYDIR_STRING(s) _TEXT(s)
+#define _tinydir_strlen   _tcslen
+#define _tinydir_strcpy   _tcscpy
+#define _tinydir_strcat   _tcscat
+#define _tinydir_strcmp   _tcscmp
+#define _tinydir_strrchr  _tcsrchr
+#define _tinydir_strncmp  _tcsncmp
+#else
+#define _tinydir_char_t   char
+#define TINYDIR_STRING(s) s
+#define _tinydir_strlen   strlen
+#define _tinydir_strcpy   strcpy
+#define _tinydir_strcat   strcat
+#define _tinydir_strcmp   strcmp
+#define _tinydir_strrchr  strrchr
+#define _tinydir_strncmp  strncmp
+#endif
+
+#if (defined _MSC_VER || defined __MINGW32__)
+#include <windows.h>
+#define _TINYDIR_PATH_MAX MAX_PATH
+#elif defined __linux__
+#include <limits.h>
+#ifdef PATH_MAX
+#define _TINYDIR_PATH_MAX PATH_MAX
+#endif
+#elif defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
+#include <sys/param.h>
+#if defined(BSD)
+#include <limits.h>
+#ifdef PATH_MAX
+#define _TINYDIR_PATH_MAX PATH_MAX
+#endif
+#endif
+#endif
+
+#ifndef _TINYDIR_PATH_MAX
+#define _TINYDIR_PATH_MAX 4096
+#endif
+
+#ifdef _MSC_VER
+/* extra chars for the "\\*" mask */
+#define _TINYDIR_PATH_EXTRA 2
+#else
+#define _TINYDIR_PATH_EXTRA 0
+#endif
+
+#define _TINYDIR_FILENAME_MAX 256
+
+#if (defined _MSC_VER || defined __MINGW32__)
+#define _TINYDIR_DRIVE_MAX 3
+#endif
+
+#ifdef _MSC_VER
+#define _TINYDIR_FUNC static __inline
+#elif !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
+#define _TINYDIR_FUNC static __inline__
+#elif defined(__cplusplus)
+#define _TINYDIR_FUNC static inline
+#elif defined(__GNUC__)
+/* Suppress unused function warning */
+#define _TINYDIR_FUNC __attribute__((unused)) static
+#else
+#define _TINYDIR_FUNC static
+#endif
+
+#if defined(i386) || defined(__i386__) || defined(__i386) || defined(_M_IX86)
+#ifdef _MSC_VER
+#define _TINYDIR_CDECL __cdecl
+#else
+#define _TINYDIR_CDECL __attribute__((cdecl))
+#endif
+#else
+#define _TINYDIR_CDECL
+#endif
+
+/* readdir_r usage; define TINYDIR_USE_READDIR_R to use it (if supported) */
+#ifdef TINYDIR_USE_READDIR_R
+
+/* readdir_r is a POSIX-only function, and may not be available under various
+ * environments/settings, e.g. MinGW. Use readdir fallback */
+#if _POSIX_C_SOURCE >= 1 || _XOPEN_SOURCE || _BSD_SOURCE || _SVID_SOURCE || \
+    _POSIX_SOURCE
+#define _TINYDIR_HAS_READDIR_R
+#endif
+#if _POSIX_C_SOURCE >= 200112L
+#define _TINYDIR_HAS_FPATHCONF
+#include <unistd.h>
+#endif
+#if _BSD_SOURCE || _SVID_SOURCE || \
+    (_POSIX_C_SOURCE >= 200809L || _XOPEN_SOURCE >= 700)
+#define _TINYDIR_HAS_DIRFD
+#include <sys/types.h>
+#endif
+#if defined _TINYDIR_HAS_FPATHCONF && defined _TINYDIR_HAS_DIRFD && \
+    defined _PC_NAME_MAX
+#define _TINYDIR_USE_FPATHCONF
+#endif
+#if defined __MINGW32__ || !defined _TINYDIR_HAS_READDIR_R || \
+    !(defined _TINYDIR_USE_FPATHCONF || defined NAME_MAX)
+#define _TINYDIR_USE_READDIR
+#endif
+
+/* Use readdir by default */
+#else
+#define _TINYDIR_USE_READDIR
+#endif
+
+/* MINGW32 has two versions of dirent, ASCII and UNICODE*/
+#ifndef _MSC_VER
+#if (defined __MINGW32__) && (defined _UNICODE)
+#define _TINYDIR_DIR      _WDIR
+#define _tinydir_dirent   _wdirent
+#define _tinydir_opendir  _wopendir
+#define _tinydir_readdir  _wreaddir
+#define _tinydir_closedir _wclosedir
+#else
+#define _TINYDIR_DIR      DIR
+#define _tinydir_dirent   dirent
+#define _tinydir_opendir  opendir
+#define _tinydir_readdir  readdir
+#define _tinydir_closedir closedir
+#endif
+#endif
+
+/* Allow user to use a custom allocator by defining _TINYDIR_MALLOC and
+ * _TINYDIR_FREE. */
+#if defined(_TINYDIR_MALLOC) && defined(_TINYDIR_FREE)
+#elif !defined(_TINYDIR_MALLOC) && !defined(_TINYDIR_FREE)
+#else
+#error "Either define both alloc and free or none of them!"
+#endif
+
+#if !defined(_TINYDIR_MALLOC)
+#define _TINYDIR_MALLOC(_size) malloc(_size)
+#define _TINYDIR_FREE(_ptr)    free(_ptr)
+#endif /* !defined(_TINYDIR_MALLOC) */
+
+typedef struct tinydir_file {
+  _tinydir_char_t  path[_TINYDIR_PATH_MAX];
+  _tinydir_char_t  name[_TINYDIR_FILENAME_MAX];
+  _tinydir_char_t* extension;
+  int              is_dir;
+  int              is_reg;
+
+#ifndef _MSC_VER
+#ifdef __MINGW32__
+  struct _stat _s;
+#else
+  struct stat _s;
+#endif
+#endif
+} tinydir_file;
+
+typedef struct tinydir_dir {
+  _tinydir_char_t path[_TINYDIR_PATH_MAX];
+  int             has_next;
+  size_t          n_files;
+
+  tinydir_file* _files;
+#ifdef _MSC_VER
+  HANDLE          _h;
+  WIN32_FIND_DATA _f;
+#else
+  _TINYDIR_DIR*           _d;
+  struct _tinydir_dirent* _e;
+#ifndef _TINYDIR_USE_READDIR
+  struct _tinydir_dirent* _ep;
+#endif
+#endif
+} tinydir_dir;
+
+/* declarations */
+
+_TINYDIR_FUNC
+int tinydir_open(tinydir_dir* dir, const _tinydir_char_t* path);
+_TINYDIR_FUNC
+int tinydir_open_sorted(tinydir_dir* dir, const _tinydir_char_t* path);
+_TINYDIR_FUNC
+void tinydir_close(tinydir_dir* dir);
+
+_TINYDIR_FUNC
+int tinydir_next(tinydir_dir* dir);
+_TINYDIR_FUNC
+int tinydir_readfile(const tinydir_dir* dir, tinydir_file* file);
+_TINYDIR_FUNC
+int tinydir_readfile_n(const tinydir_dir* dir, tinydir_file* file, size_t i);
+_TINYDIR_FUNC
+int tinydir_open_subdir_n(tinydir_dir* dir, size_t i);
+
+_TINYDIR_FUNC
+int tinydir_file_open(tinydir_file* file, const _tinydir_char_t* path);
+_TINYDIR_FUNC
+void _tinydir_get_ext(tinydir_file* file);
+_TINYDIR_FUNC
+int _TINYDIR_CDECL _tinydir_file_cmp(const void* a, const void* b);
+#ifndef _MSC_VER
+#ifndef _TINYDIR_USE_READDIR
+_TINYDIR_FUNC
+size_t _tinydir_dirent_buf_size(_TINYDIR_DIR* dirp);
+#endif
+#endif
+
+/* definitions*/
+
+_TINYDIR_FUNC
+int tinydir_open(tinydir_dir* dir, const _tinydir_char_t* path) {
+#ifndef _MSC_VER
+#ifndef _TINYDIR_USE_READDIR
+  int error;
+  int size; /* using int size */
+#endif
+#else
+  _tinydir_char_t path_buf[_TINYDIR_PATH_MAX];
+#endif
+  _tinydir_char_t* pathp;
+
+  if (dir == NULL || path == NULL || _tinydir_strlen(path) == 0) {
+    errno = EINVAL;
+    return -1;
+  }
+  if (_tinydir_strlen(path) + _TINYDIR_PATH_EXTRA >= _TINYDIR_PATH_MAX) {
+    errno = ENAMETOOLONG;
+    return -1;
+  }
+
+  /* initialise dir */
+  dir->_files = NULL;
+#ifdef _MSC_VER
+  dir->_h = INVALID_HANDLE_VALUE;
+#else
+  dir->_d = NULL;
+#ifndef _TINYDIR_USE_READDIR
+  dir->_ep = NULL;
+#endif
+#endif
+  tinydir_close(dir);
+
+  _tinydir_strcpy(dir->path, path);
+  /* Remove trailing slashes */
+  pathp = &dir->path[_tinydir_strlen(dir->path) - 1];
+  while (pathp != dir->path &&
+         (*pathp == TINYDIR_STRING('\\') || *pathp == TINYDIR_STRING('/'))) {
+    *pathp = TINYDIR_STRING('\0');
+    pathp++;
+  }
+#ifdef _MSC_VER
+  _tinydir_strcpy(path_buf, dir->path);
+  _tinydir_strcat(path_buf, TINYDIR_STRING("\\*"));
+#if (defined WINAPI_FAMILY) && (WINAPI_FAMILY != WINAPI_FAMILY_DESKTOP_APP)
+  dir->_h = FindFirstFileEx(
+      path_buf, FindExInfoStandard, &dir->_f, FindExSearchNameMatch, NULL, 0);
+#else
+  dir->_h = FindFirstFile(path_buf, &dir->_f);
+#endif
+  if (dir->_h == INVALID_HANDLE_VALUE) {
+    errno = ENOENT;
+#else
+  dir->_d = _tinydir_opendir(path);
+  if (dir->_d == NULL) {
+#endif
+    goto bail;
+  }
+
+  /* read first file */
+  dir->has_next = 1;
+#ifndef _MSC_VER
+#ifdef _TINYDIR_USE_READDIR
+  dir->_e = _tinydir_readdir(dir->_d);
+#else
+  /* allocate dirent buffer for readdir_r */
+  size = _tinydir_dirent_buf_size(dir->_d); /* conversion to int */
+  if (size == -1)
+    return -1;
+  dir->_ep = (struct _tinydir_dirent*)_TINYDIR_MALLOC(size);
+  if (dir->_ep == NULL)
+    return -1;
+
+  error = readdir_r(dir->_d, dir->_ep, &dir->_e);
+  if (error != 0)
+    return -1;
+#endif
+  if (dir->_e == NULL) {
+    dir->has_next = 0;
+  }
+#endif
+
+  return 0;
+
+bail:
+  tinydir_close(dir);
+  return -1;
+}
+
+_TINYDIR_FUNC
+int tinydir_open_sorted(tinydir_dir* dir, const _tinydir_char_t* path) {
+  /* Count the number of files first, to pre-allocate the files array */
+  size_t n_files = 0;
+  if (tinydir_open(dir, path) == -1) {
+    return -1;
+  }
+  while (dir->has_next) {
+    n_files++;
+    if (tinydir_next(dir) == -1) {
+      goto bail;
+    }
+  }
+  tinydir_close(dir);
+
+  if (n_files == 0 || tinydir_open(dir, path) == -1) {
+    return -1;
+  }
+
+  dir->n_files = 0;
+  dir->_files  = (tinydir_file*)_TINYDIR_MALLOC(sizeof *dir->_files * n_files);
+  if (dir->_files == NULL) {
+    goto bail;
+  }
+  while (dir->has_next) {
+    tinydir_file* p_file;
+    dir->n_files++;
+
+    p_file = &dir->_files[dir->n_files - 1];
+    if (tinydir_readfile(dir, p_file) == -1) {
+      goto bail;
+    }
+
+    if (tinydir_next(dir) == -1) {
+      goto bail;
+    }
+
+    /* Just in case the number of files has changed between the first and
+    second reads, terminate without writing into unallocated memory */
+    if (dir->n_files == n_files) {
+      break;
+    }
+  }
+
+  qsort(dir->_files, dir->n_files, sizeof(tinydir_file), _tinydir_file_cmp);
+
+  return 0;
+
+bail:
+  tinydir_close(dir);
+  return -1;
+}
+
+_TINYDIR_FUNC
+void tinydir_close(tinydir_dir* dir) {
+  if (dir == NULL) {
+    return;
+  }
+
+  memset(dir->path, 0, sizeof(dir->path));
+  dir->has_next = 0;
+  dir->n_files  = 0;
+  _TINYDIR_FREE(dir->_files);
+  dir->_files = NULL;
+#ifdef _MSC_VER
+  if (dir->_h != INVALID_HANDLE_VALUE) {
+    FindClose(dir->_h);
+  }
+  dir->_h = INVALID_HANDLE_VALUE;
+#else
+  if (dir->_d) {
+    _tinydir_closedir(dir->_d);
+  }
+  dir->_d = NULL;
+  dir->_e = NULL;
+#ifndef _TINYDIR_USE_READDIR
+  _TINYDIR_FREE(dir->_ep);
+  dir->_ep = NULL;
+#endif
+#endif
+}
+
+_TINYDIR_FUNC
+int tinydir_next(tinydir_dir* dir) {
+  if (dir == NULL) {
+    errno = EINVAL;
+    return -1;
+  }
+  if (!dir->has_next) {
+    errno = ENOENT;
+    return -1;
+  }
+
+#ifdef _MSC_VER
+  if (FindNextFile(dir->_h, &dir->_f) == 0)
+#else
+#ifdef _TINYDIR_USE_READDIR
+  dir->_e = _tinydir_readdir(dir->_d);
+#else
+  if (dir->_ep == NULL) {
+    return -1;
+  }
+  if (readdir_r(dir->_d, dir->_ep, &dir->_e) != 0) {
+    return -1;
+  }
+#endif
+  if (dir->_e == NULL)
+#endif
+  {
+    dir->has_next = 0;
+#ifdef _MSC_VER
+    if (GetLastError() != ERROR_SUCCESS &&
+        GetLastError() != ERROR_NO_MORE_FILES) {
+      tinydir_close(dir);
+      errno = EIO;
+      return -1;
+    }
+#endif
+  }
+
+  return 0;
+}
+
+_TINYDIR_FUNC
+int tinydir_readfile(const tinydir_dir* dir, tinydir_file* file) {
+  const _tinydir_char_t* filename;
+  if (dir == NULL || file == NULL) {
+    errno = EINVAL;
+    return -1;
+  }
+#ifdef _MSC_VER
+  if (dir->_h == INVALID_HANDLE_VALUE)
+#else
+  if (dir->_e == NULL)
+#endif
+  {
+    errno = ENOENT;
+    return -1;
+  }
+  filename =
+#ifdef _MSC_VER
+      dir->_f.cFileName;
+#else
+      dir->_e->d_name;
+#endif
+  if (_tinydir_strlen(dir->path) + _tinydir_strlen(filename) + 1 +
+          _TINYDIR_PATH_EXTRA >=
+      _TINYDIR_PATH_MAX) {
+    /* the path for the file will be too long */
+    errno = ENAMETOOLONG;
+    return -1;
+  }
+  if (_tinydir_strlen(filename) >= _TINYDIR_FILENAME_MAX) {
+    errno = ENAMETOOLONG;
+    return -1;
+  }
+
+  _tinydir_strcpy(file->path, dir->path);
+  if (_tinydir_strcmp(dir->path, TINYDIR_STRING("/")) != 0)
+    _tinydir_strcat(file->path, TINYDIR_STRING("/"));
+  _tinydir_strcpy(file->name, filename);
+  _tinydir_strcat(file->path, filename);
+#ifndef _MSC_VER
+#ifdef __MINGW32__
+  if (_tstat(
+#elif (defined _BSD_SOURCE) || (defined _DEFAULT_SOURCE) ||        \
+    ((defined _XOPEN_SOURCE) && (_XOPEN_SOURCE >= 500)) ||         \
+    ((defined _POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200112L)) || \
+    ((defined __APPLE__) && (defined __MACH__)) || (defined BSD)
+  if (lstat(
+#else
+  if (stat(
+#endif
+          file->path, &file->_s) == -1) {
+    return -1;
+  }
+#endif
+  _tinydir_get_ext(file);
+
+  file->is_dir =
+#ifdef _MSC_VER
+      !!(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
+#else
+      S_ISDIR(file->_s.st_mode);
+#endif
+  file->is_reg =
+#ifdef _MSC_VER
+      !!(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_NORMAL) ||
+      (!(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_DEVICE) &&
+       !(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
+       !(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED) &&
+#ifdef FILE_ATTRIBUTE_INTEGRITY_STREAM
+       !(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_INTEGRITY_STREAM) &&
+#endif
+#ifdef FILE_ATTRIBUTE_NO_SCRUB_DATA
+       !(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_NO_SCRUB_DATA) &&
+#endif
+       !(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_OFFLINE) &&
+       !(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_TEMPORARY));
+#else
+      S_ISREG(file->_s.st_mode);
+#endif
+
+  return 0;
+}
+
+_TINYDIR_FUNC
+int tinydir_readfile_n(const tinydir_dir* dir, tinydir_file* file, size_t i) {
+  if (dir == NULL || file == NULL) {
+    errno = EINVAL;
+    return -1;
+  }
+  if (i >= dir->n_files) {
+    errno = ENOENT;
+    return -1;
+  }
+
+  memcpy(file, &dir->_files[i], sizeof(tinydir_file));
+  _tinydir_get_ext(file);
+
+  return 0;
+}
+
+_TINYDIR_FUNC
+int tinydir_open_subdir_n(tinydir_dir* dir, size_t i) {
+  _tinydir_char_t path[_TINYDIR_PATH_MAX];
+  if (dir == NULL) {
+    errno = EINVAL;
+    return -1;
+  }
+  if (i >= dir->n_files || !dir->_files[i].is_dir) {
+    errno = ENOENT;
+    return -1;
+  }
+
+  _tinydir_strcpy(path, dir->_files[i].path);
+  tinydir_close(dir);
+  if (tinydir_open_sorted(dir, path) == -1) {
+    return -1;
+  }
+
+  return 0;
+}
+
+/* Open a single file given its path */
+_TINYDIR_FUNC
+int tinydir_file_open(tinydir_file* file, const _tinydir_char_t* path) {
+  tinydir_dir      dir;
+  int              result = 0;
+  int              found  = 0;
+  _tinydir_char_t  dir_name_buf[_TINYDIR_PATH_MAX];
+  _tinydir_char_t  file_name_buf[_TINYDIR_PATH_MAX];
+  _tinydir_char_t* dir_name;
+  _tinydir_char_t* base_name;
+#if (defined _MSC_VER || defined __MINGW32__)
+  _tinydir_char_t drive_buf[_TINYDIR_PATH_MAX];
+  _tinydir_char_t ext_buf[_TINYDIR_FILENAME_MAX];
+#endif
+
+  if (file == NULL || path == NULL || _tinydir_strlen(path) == 0) {
+    errno = EINVAL;
+    return -1;
+  }
+  if (_tinydir_strlen(path) + _TINYDIR_PATH_EXTRA >= _TINYDIR_PATH_MAX) {
+    errno = ENAMETOOLONG;
+    return -1;
+  }
+
+  /* Get the parent path */
+#if (defined _MSC_VER || defined __MINGW32__)
+#if ((defined _MSC_VER) && (_MSC_VER >= 1400))
+  errno = _tsplitpath_s(
+      path, drive_buf, _TINYDIR_DRIVE_MAX, dir_name_buf, _TINYDIR_FILENAME_MAX,
+      file_name_buf, _TINYDIR_FILENAME_MAX, ext_buf, _TINYDIR_FILENAME_MAX);
+#else
+  _tsplitpath(path, drive_buf, dir_name_buf, file_name_buf, ext_buf);
+#endif
+
+  if (errno) {
+    return -1;
+  }
+
+/* _splitpath_s not work fine with only filename and widechar support */
+#ifdef _UNICODE
+  if (drive_buf[0] == L'\xFEFE')
+    drive_buf[0] = '\0';
+  if (dir_name_buf[0] == L'\xFEFE')
+    dir_name_buf[0] = '\0';
+#endif
+
+  /* Emulate the behavior of dirname by returning "." for dir name if it's
+  empty */
+  if (drive_buf[0] == '\0' && dir_name_buf[0] == '\0') {
+    _tinydir_strcpy(dir_name_buf, TINYDIR_STRING("."));
+  }
+  /* Concatenate the drive letter and dir name to form full dir name */
+  _tinydir_strcat(drive_buf, dir_name_buf);
+  dir_name = drive_buf;
+  /* Concatenate the file name and extension to form base name */
+  _tinydir_strcat(file_name_buf, ext_buf);
+  base_name = file_name_buf;
+#else
+  _tinydir_strcpy(dir_name_buf, path);
+  dir_name = dirname(dir_name_buf);
+  _tinydir_strcpy(file_name_buf, path);
+  base_name = basename(file_name_buf);
+#endif
+
+  /* Special case: if the path is a root dir, open the parent dir as the file */
+#if (defined _MSC_VER || defined __MINGW32__)
+  if (_tinydir_strlen(base_name) == 0)
+#else
+  if ((_tinydir_strcmp(base_name, TINYDIR_STRING("/"))) == 0)
+#endif
+  {
+    memset(file, 0, sizeof *file);
+    file->is_dir = 1;
+    file->is_reg = 0;
+    _tinydir_strcpy(file->path, dir_name);
+    file->extension = file->path + _tinydir_strlen(file->path);
+    return 0;
+  }
+
+  /* Open the parent directory */
+  if (tinydir_open(&dir, dir_name) == -1) {
+    return -1;
+  }
+
+  /* Read through the parent directory and look for the file */
+  while (dir.has_next) {
+    if (tinydir_readfile(&dir, file) == -1) {
+      result = -1;
+      goto bail;
+    }
+    if (_tinydir_strcmp(file->name, base_name) == 0) {
+      /* File found */
+      found = 1;
+      break;
+    }
+    tinydir_next(&dir);
+  }
+  if (!found) {
+    result = -1;
+    errno  = ENOENT;
+  }
+
+bail:
+  tinydir_close(&dir);
+  return result;
+}
+
+_TINYDIR_FUNC
+void _tinydir_get_ext(tinydir_file* file) {
+  _tinydir_char_t* period = _tinydir_strrchr(file->name, TINYDIR_STRING('.'));
+  if (period == NULL) {
+    file->extension = &(file->name[_tinydir_strlen(file->name)]);
+  } else {
+    file->extension = period + 1;
+  }
+}
+
+_TINYDIR_FUNC
+int _TINYDIR_CDECL _tinydir_file_cmp(const void* a, const void* b) {
+  const tinydir_file* fa = (const tinydir_file*)a;
+  const tinydir_file* fb = (const tinydir_file*)b;
+  if (fa->is_dir != fb->is_dir) {
+    return -(fa->is_dir - fb->is_dir);
+  }
+  return _tinydir_strncmp(fa->name, fb->name, _TINYDIR_FILENAME_MAX);
+}
+
+#ifndef _MSC_VER
+#ifndef _TINYDIR_USE_READDIR
+/*
+The following authored by Ben Hutchings <ben@decadent.org.uk>
+from https://womble.decadent.org.uk/readdir_r-advisory.html
+*/
+/* Calculate the required buffer size (in bytes) for directory      *
+ * entries read from the given directory handle.  Return -1 if this  *
+ * this cannot be done.                                              *
+ *                                                                   *
+ * This code does not trust values of NAME_MAX that are less than    *
+ * 255, since some systems (including at least HP-UX) incorrectly    *
+ * define it to be a smaller value.                                  */
+_TINYDIR_FUNC
+size_t _tinydir_dirent_buf_size(_TINYDIR_DIR* dirp) {
+  long   name_max;
+  size_t name_end;
+  /* parameter may be unused */
+  (void)dirp;
+
+#if defined _TINYDIR_USE_FPATHCONF
+  name_max = fpathconf(dirfd(dirp), _PC_NAME_MAX);
+  if (name_max == -1)
+#if defined(NAME_MAX)
+    name_max = (NAME_MAX > 255) ? NAME_MAX : 255;
+#else
+    return (size_t)(-1);
+#endif
+#elif defined(NAME_MAX)
+  name_max = (NAME_MAX > 255) ? NAME_MAX : 255;
+#else
+#error "buffer size for readdir_r cannot be determined"
+#endif
+  name_end = (size_t)offsetof(struct _tinydir_dirent, d_name) + name_max + 1;
+  return (
+      name_end > sizeof(struct _tinydir_dirent)
+          ? name_end
+          : sizeof(struct _tinydir_dirent));
+}
+#endif
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#endif