superbuild/modules/physfs/extras/globbing.c

/** \file globbing.c */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>

#include "globbing.h"

/**
 * Please see globbing.h for details.
 *
 * License: this code is public domain. I make no warranty that it is useful,
 *  correct, harmless, or environmentally safe.
 *
 * This particular file may be used however you like, including copying it
 *  verbatim into a closed-source project, exploiting it commercially, and
 *  removing any trace of my name from the source (although I hope you won't
 *  do that). I welcome enhancements and corrections to this file, but I do
 *  not require you to send me patches if you make changes. This code has
 *  NO WARRANTY.
 *
 * Unless otherwise stated, the rest of PhysicsFS falls under the zlib license.
 *  Please see the file LICENSE.txt in the source's root directory.
 *
 *  \author Ryan C. Gordon.
 */


static int matchesPattern(const char *fname, const char *wildcard,
                          int caseSensitive)
{
    char x, y;
    const char *fnameptr = fname;
    const char *wildptr = wildcard;

    while ((*wildptr) && (*fnameptr))
    {
        y = *wildptr;
        if (y == '*')
        {
            do
            {
                wildptr++;  /* skip multiple '*' in a row... */
            } while (*wildptr == '*');

            y = (caseSensitive) ? *wildptr : (char) tolower(*wildptr);

            while (1)
            {
                x = (caseSensitive) ? *fnameptr : (char) tolower(*fnameptr);
                if ((!x) || (x == y))
                    break;
                else
                    fnameptr++;
            } /* while */
        } /* if */

        else if (y == '?')
        {
            wildptr++;
            fnameptr++;
        } /* else if */

        else
        {
            if (caseSensitive)
                x = *fnameptr;
            else
            {
                x = tolower(*fnameptr);
                y = tolower(y);
            } /* if */

            wildptr++;
            fnameptr++;

            if (x != y)
                return 0;
        } /* else */
    } /* while */

    while (*wildptr == '*')
        wildptr++;

    return (*fnameptr == *wildptr);
} /* matchesPattern */

typedef struct
{
    const PHYSFS_Allocator *allocator;
    const char *wildcard;
    int caseSensitive;
    PHYSFS_EnumFilesCallback callback;
    void *origData;
} WildcardCallbackData;


/*
 * This callback sits between the enumerator and the enduser callback,
 *  filtering out files that don't match the wildcard pattern.
 */
static void wildcardCallback(void *_d, const char *origdir, const char *fname)
{
    const WildcardCallbackData *data = (const WildcardCallbackData *) _d;
    if (matchesPattern(fname, data->wildcard, data->caseSensitive))
        data->callback(data->origData, origdir, fname);
} /* wildcardCallback */


void PHYSFSEXT_enumerateFilesCallbackWildcard(const char *dir,
                                              const char *wildcard,
                                              int caseSensitive,
                                              PHYSFS_EnumFilesCallback c,
                                              void *d)
{
    WildcardCallbackData data;
    data.allocator = PHYSFS_getAllocator();
    data.wildcard = wildcard;
    data.caseSensitive = caseSensitive;
    data.callback = c;
    data.origData = d;
    PHYSFS_enumerateFilesCallback(dir, wildcardCallback, &data);
} /* PHYSFSEXT_enumerateFilesCallbackWildcard */


void PHYSFSEXT_freeEnumeration(char **list)
{
    const PHYSFS_Allocator *allocator = PHYSFS_getAllocator();
    int i;
    if (list != NULL)
    {
        for (i = 0; list[i] != NULL; i++)
            allocator->Free(list[i]);
        allocator->Free(list);
    } /* if */
} /* PHYSFSEXT_freeEnumeration */


char **PHYSFSEXT_enumerateFilesWildcard(const char *dir, const char *wildcard,
                                        int caseSensitive)
{
    const PHYSFS_Allocator *allocator = PHYSFS_getAllocator();
    char **list = PHYSFS_enumerateFiles(dir);
    char **retval = NULL;
    int totalmatches = 0;
    int matches = 0;
    char **i;

    for (i = list; *i != NULL; i++)
    {
        #if 0
        printf("matchesPattern: '%s' vs '%s' (%s) ... %s\n", *i, wildcard,
               caseSensitive ? "case" : "nocase",
               matchesPattern(*i, wildcard, caseSensitive) ? "true" : "false");
        #endif
        if (matchesPattern(*i, wildcard, caseSensitive))
            totalmatches++;
    } /* for */

    retval = (char **) allocator->Malloc(sizeof (char *) * (totalmatches+1));
    if (retval != NULL)
    {
        for (i = list; ((matches < totalmatches) && (*i != NULL)); i++)
        {
            if (matchesPattern(*i, wildcard, caseSensitive))
            {
                retval[matches] = (char *) allocator->Malloc(strlen(*i) + 1);
                if (retval[matches] == NULL)
                {
                    while (matches--)
                        allocator->Free(retval[matches]);
                    allocator->Free(retval);
                    retval = NULL;
                    break;
                } /* if */
                strcpy(retval[matches], *i);
                matches++;
            } /* if */
        } /* for */

        if (retval != NULL)
        {
            assert(totalmatches == matches);
            retval[matches] = NULL;
        } /* if */
    } /* if */

    PHYSFS_freeList(list);
    return retval;
} /* PHYSFSEXT_enumerateFilesWildcard */


#ifdef TEST_PHYSFSEXT_ENUMERATEFILESWILDCARD
int main(int argc, char **argv)
{
    int rc;
    char **flist;
    char **i;

    if (argc != 3)
    {
        printf("USAGE: %s <pattern> <caseSen>\n"
               "   where <caseSen> is 1 or 0.\n", argv[0]);
        return 1;
    } /* if */

    if (!PHYSFS_init(argv[0]))
    {
        fprintf(stderr, "PHYSFS_init(): %s\n", PHYSFS_getLastError());
        return 1;
    } /* if */

    if (!PHYSFS_addToSearchPath(".", 1))
    {
        fprintf(stderr, "PHYSFS_addToSearchPath(): %s\n", PHYSFS_getLastError());
        PHYSFS_deinit();
        return 1;
    } /* if */

    flist = PHYSFSEXT_enumerateFilesWildcard("/", argv[1], atoi(argv[2]));
    rc = 0;
    for (i = flist; *i; i++)
    {
        printf("%s\n", *i);
        rc++;
    } /* for */
    printf("\n  total %d files.\n\n", rc);

    PHYSFSEXT_freeEnumeration(flist);
    PHYSFS_deinit();

    return 0;
} /* main */
#endif

/* end of globbing.c ... */