ls_filter.c

Go to the documentation of this file.

/*!
 * \file lib/gis/ls_filter.c
 *
 * \brief GIS Library - Filename filter functions
 *
 * (C) 2010 by Glynn Clements and the GRASS Development Team
 *
 * This program is free software under the GNU General Public License
 * (>=v2). Read the file COPYING that comes with GRASS for details.
 *
 * \author Original author Glynn Clements
 */

#include <grass/config.h>
#include <grass/gis.h>

#ifdef HAVE_REGEX_H

#include <regex.h>

struct buffer
{
    char *buf;
    size_t len;
    size_t alloc;
};

static void init(struct buffer *buf)
{
    buf->buf = NULL;
    buf->len = 0;
    buf->alloc = 0;
}

static void add(struct buffer *buf, char c)
{
    if (buf->len >= buf->alloc) {
        buf->alloc += 50;
        buf->buf = G_realloc(buf->buf, buf->alloc);
    }

    buf->buf[buf->len++] = c;
}

static void fini(struct buffer *buf)
{
    G_free(buf->buf);
}

static const char *do_set(struct buffer *buf, const char *p)
{
    add(buf, '[');

    if (*p == '!') {
        add(buf, '^');
        p++;
    }

    if (*p == ']') {
        add(buf, ']');
        p++;
    }

    for (; *p && *p != ']'; p++)
        add(buf, *p);

    if (!*p)
        return NULL;

    add(buf, ']');

    return p;
}

static int wc2regex(struct buffer *buf, const char *pat)
{
    const char *p;
    int in_brace = 0;

    init(buf);

    add(buf, '^');

    for (p = pat; p && *p; p++) {
        switch (*p) {
        case '\\':
            add(buf, '\\');
            if (!*++p)
                return 0;
            add(buf, *p);
            break;
        case '.':
        case '|':
        case '(':
        case ')':
        case '+':
            add(buf, '\\');
            add(buf, *p);
            break;
        case '*':
            add(buf, '.');
            add(buf, '*');
            break;
        case '?':
            add(buf, '.');
            break;
        case '{':
            in_brace++;
            add(buf, '(');
            break;
        case '}':
            if (!in_brace)
                return 0;
            in_brace--;
            add(buf, ')');
            break;
        case ',':
            if (in_brace)
                add(buf, '|');
            else
                add(buf, ',');
            break;
        case '[':
            if (!(p = do_set(buf, p)))
                return 0;
            break;
        default:
            add(buf, *p);
            break;
        }
    }

    if (!p)
        return 0;

    if (in_brace)
        return 0;

    add(buf, '$');
    add(buf, '\0');

    return 1;
}

static int re_filter(const char *filename, void *closure)
{
    regex_t *regex = closure;

    return filename[0] != '.' && regexec(regex, filename, 0, NULL, 0) == 0;
}

void *G_ls_regex_filter(const char *pat, int exclude, int extended,
                        int ignorecase)
{
    regex_t *regex = G_malloc(sizeof(regex_t));

    if (regcomp(regex, pat, REG_NOSUB |
                            (extended ? REG_EXTENDED : 0) |
                            (ignorecase ? REG_ICASE : 0)) != 0) {
        G_free(regex);
        return NULL;
    }

    if (exclude)
        G_set_ls_exclude_filter(re_filter, regex);
    else
        G_set_ls_filter(re_filter, regex);

    return regex;
}

void *G_ls_glob_filter(const char *pat, int exclude, int ignorecase)
{
    struct buffer buf;
    regex_t *regex;

    init(&buf);

    if (!wc2regex(&buf, pat)) {
        fini(&buf);
        return NULL;
    }

    regex = G_ls_regex_filter(buf.buf, exclude, 1, ignorecase);

    fini(&buf);

    return regex;
}

void G_free_ls_filter(void *regex)
{
    if (!regex)
        return;

    regfree(regex);
    G_free(regex);
}

#endif