tinydir.h File Reference

#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <libgen.h>
#include <sys/stat.h>
#include <stddef.h>

Include dependency graph for tinydir.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	tinydir_file
struct	tinydir_dir

Macros
#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
#define	_TINYDIR_PATH_MAX   4096
#define	_TINYDIR_PATH_EXTRA   0
#define	_TINYDIR_FILENAME_MAX   256
#define	_TINYDIR_FUNC   static __inline__
#define	_TINYDIR_USE_READDIR
#define	_TINYDIR_DIR   DIR
#define	_tinydir_dirent   dirent
#define	_tinydir_opendir   opendir
#define	_tinydir_readdir   readdir
#define	_tinydir_closedir   closedir
#define	_TINYDIR_MALLOC(_size)   malloc(_size)
#define	_TINYDIR_FREE(_ptr)   free(_ptr)

Typedefs
typedef struct tinydir_file	tinydir_file
typedef struct tinydir_dir	tinydir_dir

Functions
_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_file_cmp (const void *a, const void *b)

Macro Definition Documentation

_tinydir_char_t

#define _tinydir_char_t   char

Definition at line 79 of file tinydir.h.

_tinydir_closedir

#define _tinydir_closedir   closedir

Definition at line 177 of file tinydir.h.

_TINYDIR_DIR

#define _TINYDIR_DIR   DIR

Definition at line 173 of file tinydir.h.

_tinydir_dirent

#define _tinydir_dirent   dirent

Definition at line 174 of file tinydir.h.

_TINYDIR_FILENAME_MAX

#define _TINYDIR_FILENAME_MAX   256

Definition at line 118 of file tinydir.h.

_TINYDIR_FREE

#define _TINYDIR_FREE

(

_ptr

)

free(_ptr)

Definition at line 190 of file tinydir.h.

_TINYDIR_FUNC

#define _TINYDIR_FUNC   static __inline__

Definition at line 127 of file tinydir.h.

_TINYDIR_MALLOC

#define _TINYDIR_MALLOC

(

_size

)

malloc(_size)

Definition at line 189 of file tinydir.h.

_tinydir_opendir

#define _tinydir_opendir   opendir

Definition at line 175 of file tinydir.h.

_TINYDIR_PATH_EXTRA

#define _TINYDIR_PATH_EXTRA   0

Definition at line 115 of file tinydir.h.

_TINYDIR_PATH_MAX

#define _TINYDIR_PATH_MAX   4096

Definition at line 108 of file tinydir.h.

_tinydir_readdir

#define _tinydir_readdir   readdir

Definition at line 176 of file tinydir.h.

_tinydir_strcat

#define _tinydir_strcat   strcat

Definition at line 83 of file tinydir.h.

_tinydir_strcmp

#define _tinydir_strcmp   strcmp

Definition at line 84 of file tinydir.h.

_tinydir_strcpy

#define _tinydir_strcpy   strcpy

Definition at line 82 of file tinydir.h.

_tinydir_strlen

#define _tinydir_strlen   strlen

Definition at line 81 of file tinydir.h.

_tinydir_strncmp

#define _tinydir_strncmp   strncmp

Definition at line 86 of file tinydir.h.

_tinydir_strrchr

#define _tinydir_strrchr   strrchr

Definition at line 85 of file tinydir.h.

_TINYDIR_USE_READDIR

#define _TINYDIR_USE_READDIR

Definition at line 161 of file tinydir.h.

TINYDIR_STRING

#define TINYDIR_STRING

(

s

)

s

Definition at line 80 of file tinydir.h.

Typedef Documentation

tinydir_dir

typedef struct tinydir_dir tinydir_dir

tinydir_file

typedef struct tinydir_file tinydir_file

Function Documentation

_tinydir_file_cmp()

_TINYDIR_FUNC int _tinydir_file_cmp	(	const void *	a,
		const void *	b
	)

Definition at line 771 of file tinydir.h.

{
    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);
}

Referenced by tinydir_open_sorted().

_tinydir_get_ext()

_TINYDIR_FUNC void _tinydir_get_ext

(

tinydir_file *

file

)

Definition at line 757 of file tinydir.h.

{
    _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;
    }
}

Referenced by tinydir_readfile(), and tinydir_readfile_n().

tinydir_close()

_TINYDIR_FUNC void tinydir_close

(

tinydir_dir *

dir

)

Definition at line 419 of file tinydir.h.

{
    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
}

Referenced by tinydir_file_open(), tinydir_next(), tinydir_open(), tinydir_open_sorted(), and tinydir_open_subdir_n().

tinydir_file_open()

_TINYDIR_FUNC int tinydir_file_open	(	tinydir_file *	file,
		const _tinydir_char_t *	path
	)

Definition at line 633 of file tinydir.h.

{
    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_FILENAME_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_next()

_TINYDIR_FUNC int tinydir_next

(

tinydir_dir *

dir

)

Definition at line 452 of file tinydir.h.

{
    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;
}

Referenced by tinydir_file_open(), and tinydir_open_sorted().

tinydir_open()

_TINYDIR_FUNC int tinydir_open	(	tinydir_dir *	dir,
		const _tinydir_char_t *	path
	)

Definition at line 265 of file tinydir.h.

{
#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;
}

Referenced by tinydir_file_open(), and tinydir_open_sorted().

tinydir_open_sorted()

_TINYDIR_FUNC int tinydir_open_sorted	(	tinydir_dir *	dir,
		const _tinydir_char_t *	path
	)

Definition at line 356 of file tinydir.h.

{
    /* 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;
}

Referenced by process_sub(), and tinydir_open_subdir_n().

tinydir_open_subdir_n()

_TINYDIR_FUNC int tinydir_open_subdir_n	(	tinydir_dir *	dir,
		size_t	i
	)

Definition at line 607 of file tinydir.h.

{
    _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;
}

tinydir_readfile()

_TINYDIR_FUNC int tinydir_readfile	(	const tinydir_dir *	dir,
		tinydir_file *	file
	)

Definition at line 499 of file tinydir.h.

{
    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))
    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;
}

Referenced by tinydir_file_open(), and tinydir_open_sorted().

tinydir_readfile_n()

_TINYDIR_FUNC int tinydir_readfile_n	(	const tinydir_dir *	dir,
		tinydir_file *	file,
		size_t	i
	)

Definition at line 587 of file tinydir.h.

{
    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;
}

Referenced by process_sub().