/* Open SoundControl kit in C++                                              */
/* Copyright (C) 2002-2004 libOSC++ contributors. See AUTHORS                */
/*                                                                           */
/* This library is free software; you can redistribute it and/or             */
/* modify it under the terms of the GNU Lesser General Public                */
/* License as published by the Free Software Foundation; either              */
/* version 2.1 of the License, or (at your option) any later version.        */
/*                                                                           */
/* This library is distributed in the hope that it will be useful,           */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of            */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         */
/* Lesser General Public License for more details.                           */
/*                                                                           */
/* You should have received a copy of the GNU Lesser General Public          */
/* License along with this library; if not, write to the Free Software       */
/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
/*                                                                           */
/* For questions regarding this program contact                              */
/* Daniel Holth <dholth@fastmail.fm> or visit                                */
/* http://wiretap.stetson.edu/                                               */

/* In the sprit of the public domain, my modifications to this file are also */
/* dedicated to the public domain. Daniel Holth, Oct. 2004                   */

/* ChangeLog:
 * 
 * 2004-10-29 Import, convert to C++, begin OSC syntax changes. -dwh
 *              OSC syntax changes are now working, needs more testing.
 *
 */

// Original header and syntax: 

/*
 * robust glob pattern matcher
 * ozan s. yigit/dec 1994
 * public domain
 *
 * glob patterns:
 *  *   matches zero or more characters
 *  ?   matches any single character
 *  [set]   matches any character in the set
 *  [^set]  matches any character NOT in the set
 *      where a set is a group of characters or ranges. a range
 *      is written as two characters seperated with a hyphen: a-z denotes
 *      all characters between a to z inclusive.
 *  [-set]  set matches a literal hypen and any character in the set
 *  []set]  matches a literal close bracket and any character in the set
 *
 *  char    matches itself except where char is '*' or '?' or '['
 *  \char   matches char, including any pattern character
 *
 * examples:
 *  a*c     ac abc abbc ...
 *  a?c     acc abc aXc ...
 *  a[a-z]c     aac abc acc ...
 *  a[-a-z]c    a-c aac abc ...
 *
 * $Log$
 * Revision 1.1  2004/11/19 23:00:57  theno23
 * Added lo_send_timestamped
 *
 * Revision 1.3  1995/09/14  23:24:23  oz
 * removed boring test/main code.
 *
 * Revision 1.2  94/12/11  10:38:15  oz
 * cset code fixed. it is now robust and interprets all
 * variations of cset [i think] correctly, including [z-a] etc.
 * 
 * Revision 1.1  94/12/08  12:45:23  oz
 * Initial revision
 */

#include "lo.h"

#ifndef NEGATE
#define NEGATE  '!'
#endif

#ifndef true
#define true 1
#endif
#ifndef false
#define false 0
#endif

int lo_pattern_match(const char *str, const char *p)
{
    int negate;
    int match;
    char c;

    while (*p) {
        if (!*str && *p != '*')
            return false;

        switch (c = *p++) {

            case '*':
                while (*p == '*' && *p != '/')
                    p++;

                if (!*p)
                    return true;

//                if (*p != '?' && *p != '[' && *p != '\\')
                if (*p != '?' && *p != '[' && *p != '{')
                    while (*str && *p != *str)
                        str++;

                while (*str) {
                    if (lo_pattern_match(str, p))
                        return true;
                    str++;
                }
                return false;

            case '?':
                if (*str)
                    break;
                return false;
                /*
                 * set specification is inclusive, that is [a-z] is a, z and
                 * everything in between. this means [z-a] may be interpreted
                 * as a set that contains z, a and nothing in between.
                 */
            case '[':
                if (*p != NEGATE)
                    negate = false;
                else {
                    negate = true;
                    p++;
                }

                match = false;

                while (!match && (c = *p++)) {
                    if (!*p)
                        return false;
                    if (*p == '-') {    /* c-c */
                        if (!*++p)
                            return false;
                        if (*p != ']') {
                            if (*str == c || *str == *p ||
                                    (*str > c && *str < *p))
                                match = true;
                        }
                        else {      /* c-] */
                            if (*str >= c)
                                match = true;
                            break;
                        }
                    }
                    else {          /* cc or c] */
                        if (c == *str)
                            match = true;
                        if (*p != ']') {
                            if (*p == *str)
                                match = true;
                        }
                        else
                            break;
                    }
                }

                if (negate == match)
                    return false;
                /*
                 * if there is a match, skip past the cset and continue on
                 */
                while (*p && *p != ']')
                    p++;
                if (!*p++)  /* oops! */
                    return false;
                break;

                /*
                 * {astring,bstring,cstring}
                 */
            case '{':
                {
                    // *p is now first character in the {brace list}
                    const char *place = str;    // to backtrack
                    const char *remainder = p;  // to forwardtrack

                    // find the end of the brace list
                    while (*remainder && *remainder != '}')
                        remainder++;
                    if (!*remainder++)  /* oops! */
                        return false;

                    c = *p++;

                    while (c) {
                        if (c == ',') {
                            if(lo_pattern_match(str, remainder)) {
                                return true;
                            } else {
                                // backtrack on test string
                                str = place;
                                // continue testing,
                                // skip comma
                                if (!*p++)  // oops
                                    return false;
                            }
                        }
                        else if (c == '}') {
                            // continue normal pattern matching
                            if (!*p && !*str) return true;
                            str--; // str is incremented again below
                            break;
                        } else if (c == *str) {
                            str++;
                            if (!*str && *remainder) 
                                return false;
                        } else { // skip to next comma
                            str = place;
                            while (*p != ',' && *p != '}' && *p)
                                p++;
                            if (*p == ',')
                                p++;
                            else if (*p == '}') {
                                return false;
                            }
                        }
                        c = *p++;
                    }
                }

                break;

                /* Not part of OSC pattern matching
                   case '\\':
                   if (*p)
                   c = *p++;
                   */

            default:
                if (c != *str)
                    return false;
                break;

        }
        str++;
    }

    return !*str;
}