• Skip to content
• Skip to link menu

KDE 4.4 API Reference

• KDE API Reference
• KDE Support

• Sitemap
• Contact Us

 

strigi/src/streams

fnmatch.cpp

Go to the documentation of this file.

/*
 * Copyright (c) 1989, 1993, 1994 Guido van Rossum <guido@python.org>
 *      The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Guido van Rossum <guido@python.org>.
 *
 * 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.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by the University of
 *      California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
 */

#include <ctype.h>
#include "strigi_fnmatch.h"

/*
 * Function fnmatch() as specified in POSIX 1003.2-1992, section B.6.
 * Compares a filename or pathname to a pattern.
 */
#include <string.h>

#define EOS '\0'

static const char *rangematch(const char *, int, int);

int fnmatch(const char *pattern, const char *string, int flags)
{
    const char *stringstart;
    char c, test;

    for (stringstart = string;;) {
    switch (c = *pattern++) {
    case EOS:
        return (*string == EOS ? SUCCESS : FNM_NOMATCH);
    case '?':
        if (*string == EOS) {
        return (FNM_NOMATCH);
        }
        if (*string == '/' && (flags & FNM_PATHNAME)) {
        return (FNM_NOMATCH);
        }
        if (*string == '.' && (flags & FNM_PERIOD) &&
        (string == stringstart ||
         ((flags & FNM_PATHNAME) && *(string - 1) == '/'))) {
        return (FNM_NOMATCH);
        }
        ++string;
        break;
    case '*':
        c = *pattern;
        /* Collapse multiple stars. */
        while (c == '*') {
        c = *++pattern;
        }

        if (*string == '.' && (flags & FNM_PERIOD) &&
        (string == stringstart ||
         ((flags & FNM_PATHNAME) && *(string - 1) == '/'))) {
        return (FNM_NOMATCH);
        }

        /* Optimize for pattern with * at end or before /. */
        if (c == EOS) {
        if (flags & FNM_PATHNAME) {
            return (strchr(string, '/') == NULL ? SUCCESS : FNM_NOMATCH);
        }
        else {
            return (SUCCESS);
        }
        }
        else if (c == '/' && flags & FNM_PATHNAME) {
            if ((string = strchr(string, '/')) == NULL) {
            return (FNM_NOMATCH);
        }
        break;
        }

        /* General case, use recursion. */
        while ((test = *string) != EOS) {
            if (!fnmatch(pattern, string, flags & ~FNM_PERIOD)) {
            return (SUCCESS);
        }
        if (test == '/' && flags & FNM_PATHNAME) {
            break;
        }
        ++string;
        }
        return (FNM_NOMATCH);
    case '[':
        if (*string == EOS) {
        return (FNM_NOMATCH);
        }
        if (*string == '/' && flags & FNM_PATHNAME) {
        return (FNM_NOMATCH);
        }
        if (*string == '.' && (flags & FNM_PERIOD) &&
        (string == stringstart ||
         ((flags & FNM_PATHNAME) && *(string - 1) == '/'))) {
            return (FNM_NOMATCH);
        }
        if ((pattern = rangematch(pattern, *string, flags)) == NULL) {
        return (FNM_NOMATCH);
        }
        ++string;
        break;
    case '\\':
        if (!(flags & FNM_NOESCAPE)) {
        if ((c = *pattern++) == EOS) {
            c = '\\';
            --pattern;
        }
        }
        /* FALLTHROUGH */
    default:
        if (flags & FNM_CASE_BLIND) {
            if (tolower(c) != tolower(*string)) {
            return (FNM_NOMATCH);
        }
        }
        else if (c != *string) {
            return (FNM_NOMATCH);
        }
        string++;
        break;
    }
    /* NOTREACHED */
    }
}

static const char *rangematch(const char *pattern, int test, int flags)
{
    int negate, ok;
    char c, c2;

    /*
     * A bracket expression starting with an unquoted circumflex
     * character produces unspecified results (IEEE 1003.2-1992,
     * 3.13.2).  This implementation treats it like '!', for
     * consistency with the regular expression syntax.
     * J.T. Conklin (conklin@ngai.kaleida.com)
     */
    if ((negate = (*pattern == '!' || *pattern == '^'))) {
    ++pattern;
    }

    for (ok = 0; (c = *pattern++) != ']';) {
        if (c == '\\' && !(flags & FNM_NOESCAPE)) {
        c = *pattern++;
    }
    if (c == EOS) {
        return (NULL);
    }
    if (*pattern == '-' && (c2 = *(pattern + 1)) != EOS && c2 != ']') {
        pattern += 2;
        if (c2 == '\\' && !(flags & FNM_NOESCAPE)) {
        c2 = *pattern++;
        }
        if (c2 == EOS) {
        return (NULL);
        }
        if ((c <= test && test <= c2)
        || ((flags & FNM_CASE_BLIND)
            && ((tolower(c) <= tolower(test))
            && (tolower(test) <= tolower(c2))))) {
        ok = 1;
        }
    }
    else if ((c == test)
         || ((flags & FNM_CASE_BLIND)
             && (tolower(c) == tolower(test)))) {
        ok = 1;
    }
    }
    return (ok == negate ? NULL : pattern);
}


/* This function is an Apache addition */
/* return non-zero if pattern has any glob chars in it */
int fnmatch_test(const char *pattern)
{
    int nesting;

    nesting = 0;
    while (*pattern) {
    switch (*pattern) {
    case '?':
    case '*':
        return 1;

    case '\\':
        if (*pattern++ == '\0') {
        return 0;
        }
        break;

    case '[':   /* '[' is only a glob if it has a matching ']' */
        ++nesting;
        break;

    case ']':
        if (nesting) {
        return 1;
        }
        break;
    }
    ++pattern;
    }
    return 0;
}

/* Deprecated */
int is_fnmatch(const char *pattern)
{
    return fnmatch_test(pattern);
}

strigi/src/streams

Skip menu "strigi/src/streams"

• Main Page
• Namespace List
• Class Hierarchy
• Alphabetical List
• Class List
• File List
• Namespace Members
• Class Members

KDE Support

Skip menu "KDE Support"

• akonadi
• Decibel
• grantlee
• kdewin
• phonon
•     Backend
• polkit-qt
• qca
• qimageblitz
• soprano
• strigi
•     searchclient
•     streamanalyzer
•     streams

Generated for KDE Support by doxygen 1.5.9-20090814
This website is maintained by Adriaan de Groot and Allen Winter.
KDE^® and the K Desktop Environment^® logo are registered trademarks of KDE e.V. | Legal