yquake2remaster/src/common/glob.c

/*
 * Copyright (C) 1997-2001 Id Software, Inc.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 * =======================================================================
 *
 * Global string matching
 *
 * =======================================================================
 */

#include <stdio.h>
#include "header/glob.h"

/*
 * Like glob_match, but match PATTERN against any final segment of TEXT.
 */
static int
glob_match_after_star ( char *pattern, char *text )
{
	register char *p = pattern, *t = text;
	register char c, c1;

	while ( ( c = *p++ ) == '?' || c == '*' )
	{
		if ( ( c == '?' ) && ( *t++ == '\0' ) )
		{
			return ( 0 );
		}
	}

	if ( c == '\0' )
	{
		return ( 1 );
	}

	if ( c == '\\' )
	{
		c1 = *p;
	}
	else
	{
		c1 = c;
	}

	while ( 1 )
	{
		if ( ( ( c == '[' ) || ( *t == c1 ) ) && glob_match( p - 1, t ) )
		{
			return ( 1 );
		}

		if ( *t++ == '\0' )
		{
			return ( 0 );
		}
	}
}

/* Match the pattern PATTERN against the string TEXT;
 * return 1 if it matches, 0 otherwise.
 *
 * A match means the entire string TEXT is used up in matching.
 *
 * In the pattern string, `*' matches any sequence of characters,
 * `?' matches any character, [SET] matches any character in the specified set,
 * [!SET] matches any character not in the specified set.
 *
 * A set is composed of characters or ranges; a range looks like
 * character hyphen character (as in 0-9 or A-Z).
 * [0-9a-zA-Z_] is the set of characters allowed in C identifiers.
 * Any other character in the pattern must be matched exactly.
 *
 * To suppress the special syntactic significance of any of `[]*?!-\',
 * and match the character exactly, precede it with a `\'.
 */
int
glob_match ( char *pattern, char *text )
{
	register char *p = pattern, *t = text;
	register char c;

	while ( ( c = *p++ ) != '\0' )
	{
		switch ( c )
		{
			case '?':

				if ( *t == '\0' )
				{
					return ( 0 );
				}
				else
				{
					++t;
				}

				break;

			case '\\':

				if ( *p++ != *t++ )
				{
					return ( 0 );
				}

				break;

			case '*':
				return ( glob_match_after_star( p, t ) );

			case '[':
			{
				register char c1 = *t++;
				int invert;

				if ( !c1 )
				{
					return ( 0 );
				}

				invert = ( ( *p == '!' ) || ( *p == '^' ) );

				if ( invert )
				{
					p++;
				}

				c = *p++;

				while ( 1 )
				{
					register char cstart = c, cend = c;

					if ( c == '\\' )
					{
						cstart = *p++;
						cend = cstart;
					}

					if ( c == '\0' )
					{
						return ( 0 );
					}

					c = *p++;

					if ( ( c == '-' ) && ( *p != ']' ) )
					{
						cend = *p++;

						if ( cend == '\\' )
						{
							cend = *p++;
						}

						if ( cend == '\0' )
						{
							return ( 0 );
						}

						c = *p++;
					}

					if ( ( c1 >= cstart ) && ( c1 <= cend ) )
					{
						goto match;
					}

					if ( c == ']' )
					{
						break;
					}
				}

				if ( !invert )
				{
					return ( 0 );
				}

				break;

			match:

				/* Skip the rest of the [...] construct that already matched.  */
				while ( c != ']' )
				{
					if ( c == '\0' )
					{
						return ( 0 );
					}

					c = *p++;

					if ( c == '\0' )
					{
						return ( 0 );
					}
					else if ( c == '\\' )
					{
						++p;
					}
				}

				if ( invert )
				{
					return ( 0 );
				}

				break;
			}

			default:

				if ( c != *t++ )
				{
					return ( 0 );
				}
		}
	}

	return ( *t == '\0' );
}