[rsync/rsync.git] / lib / fnmatch.c

#include "../rsync.h"
#ifndef HAVE_FNMATCH

/* ----- THE FOLLOWING UP TO 'END' is glibc-2.1.2 posix/fnmatch.c
     except for the parts with '#if 0' */

/* Copyright (C) 1991, 92, 93, 96, 97, 98, 99 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public License as
   published by the Free Software Foundation; either version 2 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#if 0	/* header files included better by ../rsync.h */

#if HAVE_CONFIG_H
# include <config.h>
#endif

/* Enable GNU extensions in fnmatch.h.  */
#ifndef _GNU_SOURCE
# define _GNU_SOURCE	1
#endif

#include <errno.h>
#include <fnmatch.h>
#include <ctype.h>

#if HAVE_STRING_H || defined _LIBC
# include <string.h>
#else
# include <strings.h>
#endif

#if defined STDC_HEADERS || defined _LIBC
# include <stdlib.h>
#endif

#endif /* 0 */

/* For platform which support the ISO C amendement 1 functionality we
   support user defined character classes.  */
#if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
/* Solaris 2.5 has a bug: <wchar.h> must be included before <wctype.h>.  */
# include <wchar.h>
# include <wctype.h>
#endif

/* Comment out all this code if we are using the GNU C Library, and are not
   actually compiling the library itself.  This code is part of the GNU C
   Library, but also included in many other GNU distributions.  Compiling
   and linking in this code is a waste when using the GNU C library
   (especially if it is a shared library).  Rather than having every GNU
   program understand `configure --with-gnu-libc' and omit the object files,
   it is simpler to just do this in the source for each such file.  */

#if defined _LIBC || !defined __GNU_LIBRARY__


# if defined STDC_HEADERS || !defined isascii
#  define ISASCII(c) 1
# else
#  define ISASCII(c) isascii(c)
# endif

#ifdef isblank
# define ISBLANK(c) (ISASCII (c) && isblank (c))
#else
# define ISBLANK(c) ((c) == ' ' || (c) == '\t')
#endif
#ifdef isgraph
# define ISGRAPH(c) (ISASCII (c) && isgraph (c))
#else
# define ISGRAPH(c) (ISASCII (c) && isprint (c) && !isspace (c))
#endif

#define ISPRINT(c) (ISASCII (c) && isprint (c))
#define ISDIGIT(c) (ISASCII (c) && isdigit (c))
#define ISALNUM(c) (ISASCII (c) && isalnum (c))
#define ISALPHA(c) (ISASCII (c) && isalpha (c))
#define ISCNTRL(c) (ISASCII (c) && iscntrl (c))
#define ISLOWER(c) (ISASCII (c) && islower (c))
#define ISPUNCT(c) (ISASCII (c) && ispunct (c))
#define ISSPACE(c) (ISASCII (c) && isspace (c))
#define ISUPPER(c) (ISASCII (c) && isupper (c))
#define ISXDIGIT(c) (ISASCII (c) && isxdigit (c))

# define STREQ(s1, s2) ((strcmp (s1, s2) == 0))

# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
/* The GNU C library provides support for user-defined character classes
   and the functions from ISO C amendement 1.  */
#  ifdef CHARCLASS_NAME_MAX
#   define CHAR_CLASS_MAX_LENGTH CHARCLASS_NAME_MAX
#  else
/* This shouldn't happen but some implementation might still have this
   problem.  Use a reasonable default value.  */
#   define CHAR_CLASS_MAX_LENGTH 256
#  endif

#  ifdef _LIBC
#   define IS_CHAR_CLASS(string) __wctype (string)
#  else
#   define IS_CHAR_CLASS(string) wctype (string)
#  endif
# else
#  define CHAR_CLASS_MAX_LENGTH  6 /* Namely, `xdigit'.  */

#  define IS_CHAR_CLASS(string)						      \
   (STREQ (string, "alpha") || STREQ (string, "upper")			      \
    || STREQ (string, "lower") || STREQ (string, "digit")		      \
    || STREQ (string, "alnum") || STREQ (string, "xdigit")		      \
    || STREQ (string, "space") || STREQ (string, "print")		      \
    || STREQ (string, "punct") || STREQ (string, "graph")		      \
    || STREQ (string, "cntrl") || STREQ (string, "blank"))
# endif

/* Avoid depending on library functions or files
   whose names are inconsistent.  */

# if !defined _LIBC && !defined getenv
extern char *getenv ();
# endif

# ifndef errno
extern int errno;
# endif

/* Match STRING against the filename pattern PATTERN, returning zero if
   it matches, nonzero if not.  */
static int
#ifdef _LIBC
internal_function
#endif
internal_fnmatch (const char *pattern, const char *string,
		  int no_leading_period, int flags)
{
  register const char *p = pattern, *n = string;
  register unsigned char c;

/* Note that this evaluates C many times.  */
# ifdef _LIBC
#  define FOLD(c) ((flags & FNM_CASEFOLD) ? tolower (c) : (c))
# else
#  define FOLD(c) ((flags & FNM_CASEFOLD) && ISUPPER (c) ? tolower (c) : (c))
# endif

  while ((c = *p++) != '\0')
    {
      c = FOLD (c);

      switch (c)
	{
	case '?':
	  if (*n == '\0')
	    return FNM_NOMATCH;
	  else if (*n == '/' && (flags & FNM_FILE_NAME))
	    return FNM_NOMATCH;
	  else if (*n == '.' && no_leading_period
		   && (n == string
		       || (n[-1] == '/' && (flags & FNM_FILE_NAME))))
	    return FNM_NOMATCH;
	  break;

	case '\\':
	  if (!(flags & FNM_NOESCAPE))
	    {
	      c = *p++;
	      if (c == '\0')
		/* Trailing \ loses.  */
		return FNM_NOMATCH;
	      c = FOLD (c);
	    }
	  if (FOLD ((unsigned char) *n) != c)
	    return FNM_NOMATCH;
	  break;

	case '*':
	  if (*n == '.' && no_leading_period
	      && (n == string
		  || (n[-1] == '/' && (flags & FNM_FILE_NAME))))
	    return FNM_NOMATCH;

	  for (c = *p++; c == '?' || c == '*'; c = *p++)
	    {
	      if (*n == '/' && (flags & FNM_FILE_NAME))
		/* A slash does not match a wildcard under FNM_FILE_NAME.  */
		return FNM_NOMATCH;
	      else if (c == '?')
		{
		  /* A ? needs to match one character.  */
		  if (*n == '\0')
		    /* There isn't another character; no match.  */
		    return FNM_NOMATCH;
		  else
		    /* One character of the string is consumed in matching
		       this ? wildcard, so *??? won't match if there are
		       less than three characters.  */
		    ++n;
		}
	    }

	  if (c == '\0')
	    /* The wildcard(s) is/are the last element of the pattern.
	       If the name is a file name and contains another slash
	       this does mean it cannot match.  */
	    return ((flags & FNM_FILE_NAME) && strchr (n, '/') != NULL
		    ? FNM_NOMATCH : 0);
	  else
	    {
	      const char *endp;

#if 0
	      endp = __strchrnul (n, (flags & FNM_FILE_NAME) ? '/' : '\0');
#else
/* replace call to internal glibc function with equivalent */
	      if (!(flags & FNM_FILE_NAME) || ((endp = strchr(n, '/')) == NULL))
		endp = n + strlen(n);
#endif

	      if (c == '[')
		{
		  int flags2 = ((flags & FNM_FILE_NAME)
				? flags : (flags & ~FNM_PERIOD));

		  for (--p; n < endp; ++n)
		    if (internal_fnmatch (p, n,
					  (no_leading_period
					   && (n == string
					       || (n[-1] == '/'
						   && (flags
						       & FNM_FILE_NAME)))),
					  flags2)
			== 0)
		      return 0;
		}
	      else if (c == '/' && (flags & FNM_FILE_NAME))
		{
		  while (*n != '\0' && *n != '/')
		    ++n;
		  if (*n == '/'
		      && (internal_fnmatch (p, n + 1, flags & FNM_PERIOD,
					    flags) == 0))
		    return 0;
		}
	      else
		{
		  int flags2 = ((flags & FNM_FILE_NAME)
				? flags : (flags & ~FNM_PERIOD));

		  if (c == '\\' && !(flags & FNM_NOESCAPE))
		    c = *p;
		  c = FOLD (c);
		  for (--p; n < endp; ++n)
		    if (FOLD ((unsigned char) *n) == c
			&& (internal_fnmatch (p, n,
					      (no_leading_period
					       && (n == string
						   || (n[-1] == '/'
						       && (flags
							   & FNM_FILE_NAME)))),
					      flags2) == 0))
		      return 0;
		}
	    }

	  /* If we come here no match is possible with the wildcard.  */
	  return FNM_NOMATCH;

	case '[':
	  {
	    /* Nonzero if the sense of the character class is inverted.  */
	    static int posixly_correct;
	    register int not;
	    char cold;

	    if (posixly_correct == 0)
	      posixly_correct = getenv ("POSIXLY_CORRECT") != NULL ? 1 : -1;

	    if (*n == '\0')
	      return FNM_NOMATCH;

	    if (*n == '.' && no_leading_period && (n == string
						   || (n[-1] == '/'
						       && (flags
							   & FNM_FILE_NAME))))
	      return FNM_NOMATCH;

	    if (*n == '/' && (flags & FNM_FILE_NAME))
	      /* `/' cannot be matched.  */
	      return FNM_NOMATCH;

	    not = (*p == '!' || (posixly_correct < 0 && *p == '^'));
	    if (not)
	      ++p;

	    c = *p++;
	    for (;;)
	      {
		unsigned char fn = FOLD ((unsigned char) *n);

		if (!(flags & FNM_NOESCAPE) && c == '\\')
		  {
		    if (*p == '\0')
		      return FNM_NOMATCH;
		    c = FOLD ((unsigned char) *p);
		    ++p;

		    if (c == fn)
		      goto matched;
		  }
		else if (c == '[' && *p == ':')
		  {
		    /* Leave room for the null.  */
		    char str[CHAR_CLASS_MAX_LENGTH + 1];
		    size_t c1 = 0;
# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
		    wctype_t wt;
# endif
		    const char *startp = p;

		    for (;;)
		      {
			if (c1 == CHAR_CLASS_MAX_LENGTH)
			  /* The name is too long and therefore the pattern
			     is ill-formed.  */
			  return FNM_NOMATCH;

			c = *++p;
			if (c == ':' && p[1] == ']')
			  {
			    p += 2;
			    break;
			  }
			if (c < 'a' || c >= 'z')
			  {
			    /* This cannot possibly be a character class name.
			       Match it as a normal range.  */
			    p = startp;
			    c = '[';
			    goto normal_bracket;
			  }
			str[c1++] = c;
		      }
		    str[c1] = '\0';

# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
		    wt = IS_CHAR_CLASS (str);
		    if (wt == 0)
		      /* Invalid character class name.  */
		      return FNM_NOMATCH;

		    if (__iswctype (__btowc ((unsigned char) *n), wt))
		      goto matched;
# else
		    if ((STREQ (str, "alnum") && ISALNUM ((unsigned char) *n))
			|| (STREQ (str, "alpha") && ISALPHA ((unsigned char) *n))
			|| (STREQ (str, "blank") && ISBLANK ((unsigned char) *n))
			|| (STREQ (str, "cntrl") && ISCNTRL ((unsigned char) *n))
			|| (STREQ (str, "digit") && ISDIGIT ((unsigned char) *n))
			|| (STREQ (str, "graph") && ISGRAPH ((unsigned char) *n))
			|| (STREQ (str, "lower") && ISLOWER ((unsigned char) *n))
			|| (STREQ (str, "print") && ISPRINT ((unsigned char) *n))
			|| (STREQ (str, "punct") && ISPUNCT ((unsigned char) *n))
			|| (STREQ (str, "space") && ISSPACE ((unsigned char) *n))
			|| (STREQ (str, "upper") && ISUPPER ((unsigned char) *n))
			|| (STREQ (str, "xdigit") && ISXDIGIT ((unsigned char) *n)))
		      goto matched;
# endif
		  }
		else if (c == '\0')
		  /* [ (unterminated) loses.  */
		  return FNM_NOMATCH;
		else
		  {
		  normal_bracket:
		    if (FOLD (c) == fn)
		      goto matched;

		    cold = c;
		    c = *p++;

		    if (c == '-' && *p != ']')
		      {
			/* It is a range.  */
			unsigned char cend = *p++;
			if (!(flags & FNM_NOESCAPE) && cend == '\\')
			  cend = *p++;
			if (cend == '\0')
			  return FNM_NOMATCH;

			if (cold <= fn && fn <= FOLD (cend))
			  goto matched;

			c = *p++;
		      }
		  }

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

	    if (!not)
	      return FNM_NOMATCH;
	    break;

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

		c = *p++;
		if (!(flags & FNM_NOESCAPE) && c == '\\')
		  {
		    if (*p == '\0')
		      return FNM_NOMATCH;
		    /* XXX 1003.2d11 is unclear if this is right.  */
		    ++p;
		  }
		else if (c == '[' && *p == ':')
		  {
		    do
		      if (*++p == '\0')
			return FNM_NOMATCH;
		    while (*p != ':' || p[1] == ']');
		    p += 2;
		    c = *p;
		  }
	      }
	    if (not)
	      return FNM_NOMATCH;
	  }
	  break;

	default:
	  if (c != FOLD ((unsigned char) *n))
	    return FNM_NOMATCH;
	}

      ++n;
    }

  if (*n == '\0')
    return 0;

  if ((flags & FNM_LEADING_DIR) && *n == '/')
    /* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz".  */
    return 0;

  return FNM_NOMATCH;

# undef FOLD
}


int
fnmatch (pattern, string, flags)
     const char *pattern;
     const char *string;
     int flags;
{
  return internal_fnmatch (pattern, string, flags & FNM_PERIOD, flags);
}

#endif	/* _LIBC or not __GNU_LIBRARY__.  */
/* ----- END glibc-2.1.2 posix/fnmatch.c */

#else	/* HAVE_FNMATCH */
void fnmatch_dummy(void) {}
#endif
Commit	Line	Data
c627d613 AT	1	#include "../rsync.h"
	2	#ifndef HAVE_FNMATCH
	3
9dce9b45	4	/* ----- THE FOLLOWING UP TO 'END' is glibc-2.1.2 posix/fnmatch.c
c08bb0fb	5	except for the parts with '#if 0' */
c627d613	6
9dce9b45 DD	7	/* Copyright (C) 1991, 92, 93, 96, 97, 98, 99 Free Software Foundation, Inc.
9dce9b45 DD	8	This file is part of the GNU C Library.
c627d613	9
9dce9b45 DD	10	This library is free software; you can redistribute it and/or
	11	modify it under the terms of the GNU Library General Public License as
	12	published by the Free Software Foundation; either version 2 of the
	13	License, or (at your option) any later version.
c627d613	14
9dce9b45 DD	15	This library is distributed in the hope that it will be useful,
	16	but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	18	Library General Public License for more details.
c627d613	19
9dce9b45 DD	20	You should have received a copy of the GNU Library General Public
	21	License along with this library; see the file COPYING.LIB. If not,
	22	write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	23	Boston, MA 02111-1307, USA. */
c627d613	24
c08bb0fb DD	25	#if 0 /* header files included better by ../rsync.h */
c08bb0fb DD	26
9dce9b45 DD	27	#if HAVE_CONFIG_H
	28	# include <config.h>
	29	#endif
	30
	31	/* Enable GNU extensions in fnmatch.h. */
	32	#ifndef _GNU_SOURCE
	33	# define _GNU_SOURCE 1
	34	#endif
	35
	36	#include <errno.h>
	37	#include <fnmatch.h>
	38	#include <ctype.h>
	39
	40	#if HAVE_STRING_H \|\| defined _LIBC
	41	# include <string.h>
c627d613	42	#else
9dce9b45	43	# include <strings.h>
c627d613 AT	44	#endif
c627d613 AT	45
9dce9b45 DD	46	#if defined STDC_HEADERS \|\| defined _LIBC
	47	# include <stdlib.h>
	48	#endif
c627d613	49
c08bb0fb DD	50	#endif /* 0 */
c08bb0fb DD	51
9dce9b45 DD	52	/* For platform which support the ISO C amendement 1 functionality we
	53	support user defined character classes. */
	54	#if defined _LIBC \|\| (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
	55	/* Solaris 2.5 has a bug: <wchar.h> must be included before <wctype.h>. */
	56	# include <wchar.h>
	57	# include <wctype.h>
	58	#endif
c627d613 AT	59
	60	/* Comment out all this code if we are using the GNU C Library, and are not
	61	actually compiling the library itself. This code is part of the GNU C
	62	Library, but also included in many other GNU distributions. Compiling
	63	and linking in this code is a waste when using the GNU C library
	64	(especially if it is a shared library). Rather than having every GNU
	65	program understand `configure --with-gnu-libc' and omit the object files,
	66	it is simpler to just do this in the source for each such file. */
	67
9dce9b45 DD	68	#if defined _LIBC \|\| !defined __GNU_LIBRARY__
	69
	70
	71	# if defined STDC_HEADERS \|\| !defined isascii
	72	# define ISASCII(c) 1
	73	# else
	74	# define ISASCII(c) isascii(c)
	75	# endif
	76
	77	#ifdef isblank
	78	# define ISBLANK(c) (ISASCII (c) && isblank (c))
	79	#else
	80	# define ISBLANK(c) ((c) == ' ' \|\| (c) == '\t')
c627d613	81	#endif
9dce9b45 DD	82	#ifdef isgraph
	83	# define ISGRAPH(c) (ISASCII (c) && isgraph (c))
	84	#else
	85	# define ISGRAPH(c) (ISASCII (c) && isprint (c) && !isspace (c))
	86	#endif
	87
	88	#define ISPRINT(c) (ISASCII (c) && isprint (c))
	89	#define ISDIGIT(c) (ISASCII (c) && isdigit (c))
	90	#define ISALNUM(c) (ISASCII (c) && isalnum (c))
	91	#define ISALPHA(c) (ISASCII (c) && isalpha (c))
	92	#define ISCNTRL(c) (ISASCII (c) && iscntrl (c))
	93	#define ISLOWER(c) (ISASCII (c) && islower (c))
	94	#define ISPUNCT(c) (ISASCII (c) && ispunct (c))
	95	#define ISSPACE(c) (ISASCII (c) && isspace (c))
	96	#define ISUPPER(c) (ISASCII (c) && isupper (c))
	97	#define ISXDIGIT(c) (ISASCII (c) && isxdigit (c))
	98
	99	# define STREQ(s1, s2) ((strcmp (s1, s2) == 0))
	100
	101	# if defined _LIBC \|\| (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
	102	/* The GNU C library provides support for user-defined character classes
	103	and the functions from ISO C amendement 1. */
	104	# ifdef CHARCLASS_NAME_MAX
	105	# define CHAR_CLASS_MAX_LENGTH CHARCLASS_NAME_MAX
	106	# else
	107	/* This shouldn't happen but some implementation might still have this
	108	problem. Use a reasonable default value. */
	109	# define CHAR_CLASS_MAX_LENGTH 256
	110	# endif
	111
	112	# ifdef _LIBC
	113	# define IS_CHAR_CLASS(string) __wctype (string)
	114	# else
	115	# define IS_CHAR_CLASS(string) wctype (string)
	116	# endif
	117	# else
	118	# define CHAR_CLASS_MAX_LENGTH 6 /* Namely, `xdigit'. */
	119
	120	# define IS_CHAR_CLASS(string) \
	121	(STREQ (string, "alpha") \|\| STREQ (string, "upper") \
	122	\|\| STREQ (string, "lower") \|\| STREQ (string, "digit") \
	123	\|\| STREQ (string, "alnum") \|\| STREQ (string, "xdigit") \
	124	\|\| STREQ (string, "space") \|\| STREQ (string, "print") \
	125	\|\| STREQ (string, "punct") \|\| STREQ (string, "graph") \
	126	\|\| STREQ (string, "cntrl") \|\| STREQ (string, "blank"))
	127	# endif
	128
	129	/* Avoid depending on library functions or files
	130	whose names are inconsistent. */
	131
	132	# if !defined _LIBC && !defined getenv
	133	extern char *getenv ();
	134	# endif
	135
	136	# ifndef errno
	137	extern int errno;
	138	# endif
c627d613 AT	139
	140	/* Match STRING against the filename pattern PATTERN, returning zero if
	141	it matches, nonzero if not. */
9dce9b45 DD	142	static int
	143	#ifdef _LIBC
	144	internal_function
	145	#endif
	146	internal_fnmatch (const char pattern, const char string,
	147	int no_leading_period, int flags)
c627d613 AT	148	{
c627d613 AT	149	register const char p = pattern, n = string;
9dce9b45	150	register unsigned char c;
c627d613	151
9dce9b45 DD	152	/* Note that this evaluates C many times. */
	153	# ifdef _LIBC
	154	# define FOLD(c) ((flags & FNM_CASEFOLD) ? tolower (c) : (c))
	155	# else
	156	# define FOLD(c) ((flags & FNM_CASEFOLD) && ISUPPER (c) ? tolower (c) : (c))
	157	# endif
c627d613 AT	158
	159	while ((c = *p++) != '\0')
	160	{
	161	c = FOLD (c);
	162
	163	switch (c)
	164	{
	165	case '?':
	166	if (*n == '\0')
	167	return FNM_NOMATCH;
9dce9b45	168	else if (*n == '/' && (flags & FNM_FILE_NAME))
c627d613	169	return FNM_NOMATCH;
9dce9b45 DD	170	else if (*n == '.' && no_leading_period
	171	&& (n == string
	172	\|\| (n[-1] == '/' && (flags & FNM_FILE_NAME))))
c627d613 AT	173	return FNM_NOMATCH;
	174	break;
	175
	176	case '\\':
	177	if (!(flags & FNM_NOESCAPE))
	178	{
	179	c = *p++;
9dce9b45 DD	180	if (c == '\0')
	181	/* Trailing \ loses. */
	182	return FNM_NOMATCH;
c627d613 AT	183	c = FOLD (c);
c627d613 AT	184	}
9dce9b45	185	if (FOLD ((unsigned char) *n) != c)
c627d613 AT	186	return FNM_NOMATCH;
	187	break;
	188
	189	case '*':
9dce9b45 DD	190	if (*n == '.' && no_leading_period
	191	&& (n == string
	192	\|\| (n[-1] == '/' && (flags & FNM_FILE_NAME))))
c627d613 AT	193	return FNM_NOMATCH;
c627d613 AT	194
9dce9b45 DD	195	for (c = p++; c == '?' \|\| c == ''; c = *p++)
	196	{
	197	if (*n == '/' && (flags & FNM_FILE_NAME))
	198	/* A slash does not match a wildcard under FNM_FILE_NAME. */
	199	return FNM_NOMATCH;
	200	else if (c == '?')
	201	{
	202	/* A ? needs to match one character. */
	203	if (*n == '\0')
	204	/* There isn't another character; no match. */
	205	return FNM_NOMATCH;
	206	else
	207	/* One character of the string is consumed in matching
	208	this ? wildcard, so *??? won't match if there are
	209	less than three characters. */
	210	++n;
	211	}
	212	}
c627d613 AT	213
c627d613 AT	214	if (c == '\0')
9dce9b45 DD	215	/* The wildcard(s) is/are the last element of the pattern.
	216	If the name is a file name and contains another slash
	217	this does mean it cannot match. */
	218	return ((flags & FNM_FILE_NAME) && strchr (n, '/') != NULL
	219	? FNM_NOMATCH : 0);
	220	else
	221	{
	222	const char *endp;
c627d613	223
9dce9b45 DD	224	#if 0
	225	endp = __strchrnul (n, (flags & FNM_FILE_NAME) ? '/' : '\0');
	226	#else
	227	/* replace call to internal glibc function with equivalent */
	228	if (!(flags & FNM_FILE_NAME) \|\| ((endp = strchr(n, '/')) == NULL))
	229	endp = n + strlen(n);
	230	#endif
	231
	232	if (c == '[')
	233	{
	234	int flags2 = ((flags & FNM_FILE_NAME)
	235	? flags : (flags & ~FNM_PERIOD));
	236
	237	for (--p; n < endp; ++n)
	238	if (internal_fnmatch (p, n,
	239	(no_leading_period
	240	&& (n == string
	241	\|\| (n[-1] == '/'
	242	&& (flags
	243	& FNM_FILE_NAME)))),
	244	flags2)
	245	== 0)
	246	return 0;
	247	}
	248	else if (c == '/' && (flags & FNM_FILE_NAME))
	249	{
	250	while (n != '\0' && n != '/')
	251	++n;
	252	if (*n == '/'
	253	&& (internal_fnmatch (p, n + 1, flags & FNM_PERIOD,
	254	flags) == 0))
	255	return 0;
	256	}
	257	else
	258	{
	259	int flags2 = ((flags & FNM_FILE_NAME)
	260	? flags : (flags & ~FNM_PERIOD));
	261
	262	if (c == '\\' && !(flags & FNM_NOESCAPE))
	263	c = *p;
	264	c = FOLD (c);
	265	for (--p; n < endp; ++n)
	266	if (FOLD ((unsigned char) *n) == c
	267	&& (internal_fnmatch (p, n,
	268	(no_leading_period
	269	&& (n == string
	270	\|\| (n[-1] == '/'
	271	&& (flags
	272	& FNM_FILE_NAME)))),
	273	flags2) == 0))
	274	return 0;
	275	}
	276	}
	277
	278	/* If we come here no match is possible with the wildcard. */
	279	return FNM_NOMATCH;
c627d613 AT	280
	281	case '[':
	282	{
	283	/* Nonzero if the sense of the character class is inverted. */
9dce9b45	284	static int posixly_correct;
c627d613	285	register int not;
9dce9b45 DD	286	char cold;
	287
	288	if (posixly_correct == 0)
	289	posixly_correct = getenv ("POSIXLY_CORRECT") != NULL ? 1 : -1;
c627d613 AT	290
	291	if (*n == '\0')
	292	return FNM_NOMATCH;
	293
9dce9b45 DD	294	if (*n == '.' && no_leading_period && (n == string
	295	\|\| (n[-1] == '/'
	296	&& (flags
	297	& FNM_FILE_NAME))))
	298	return FNM_NOMATCH;
	299
	300	if (*n == '/' && (flags & FNM_FILE_NAME))
	301	/* `/' cannot be matched. */
c627d613 AT	302	return FNM_NOMATCH;
c627d613 AT	303
9dce9b45	304	not = (p == '!' \|\| (posixly_correct < 0 && p == '^'));
c627d613 AT	305	if (not)
	306	++p;
	307
	308	c = *p++;
	309	for (;;)
	310	{
9dce9b45	311	unsigned char fn = FOLD ((unsigned char) *n);
c627d613 AT	312
c627d613 AT	313	if (!(flags & FNM_NOESCAPE) && c == '\\')
9dce9b45 DD	314	{
	315	if (*p == '\0')
	316	return FNM_NOMATCH;
	317	c = FOLD ((unsigned char) *p);
	318	++p;
c627d613	319
9dce9b45 DD	320	if (c == fn)
	321	goto matched;
	322	}
	323	else if (c == '[' && *p == ':')
	324	{
	325	/* Leave room for the null. */
	326	char str[CHAR_CLASS_MAX_LENGTH + 1];
	327	size_t c1 = 0;
	328	# if defined _LIBC \|\| (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
	329	wctype_t wt;
	330	# endif
	331	const char *startp = p;
	332
	333	for (;;)
	334	{
	335	if (c1 == CHAR_CLASS_MAX_LENGTH)
	336	/* The name is too long and therefore the pattern
	337	is ill-formed. */
	338	return FNM_NOMATCH;
	339
	340	c = *++p;
	341	if (c == ':' && p[1] == ']')
	342	{
	343	p += 2;
	344	break;
	345	}
	346	if (c < 'a' \|\| c >= 'z')
	347	{
	348	/* This cannot possibly be a character class name.
	349	Match it as a normal range. */
	350	p = startp;
	351	c = '[';
	352	goto normal_bracket;
	353	}
	354	str[c1++] = c;
	355	}
	356	str[c1] = '\0';
	357
	358	# if defined _LIBC \|\| (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
	359	wt = IS_CHAR_CLASS (str);
	360	if (wt == 0)
	361	/* Invalid character class name. */
	362	return FNM_NOMATCH;
c627d613	363
9dce9b45 DD	364	if (__iswctype (__btowc ((unsigned char) *n), wt))
	365	goto matched;
	366	# else
	367	if ((STREQ (str, "alnum") && ISALNUM ((unsigned char) *n))
	368	\|\| (STREQ (str, "alpha") && ISALPHA ((unsigned char) *n))
	369	\|\| (STREQ (str, "blank") && ISBLANK ((unsigned char) *n))
	370	\|\| (STREQ (str, "cntrl") && ISCNTRL ((unsigned char) *n))
	371	\|\| (STREQ (str, "digit") && ISDIGIT ((unsigned char) *n))
	372	\|\| (STREQ (str, "graph") && ISGRAPH ((unsigned char) *n))
	373	\|\| (STREQ (str, "lower") && ISLOWER ((unsigned char) *n))
	374	\|\| (STREQ (str, "print") && ISPRINT ((unsigned char) *n))
	375	\|\| (STREQ (str, "punct") && ISPUNCT ((unsigned char) *n))
	376	\|\| (STREQ (str, "space") && ISSPACE ((unsigned char) *n))
	377	\|\| (STREQ (str, "upper") && ISUPPER ((unsigned char) *n))
	378	\|\| (STREQ (str, "xdigit") && ISXDIGIT ((unsigned char) *n)))
	379	goto matched;
	380	# endif
	381	}
	382	else if (c == '\0')
c627d613 AT	383	/* [ (unterminated) loses. */
c627d613 AT	384	return FNM_NOMATCH;
9dce9b45 DD	385	else
	386	{
	387	normal_bracket:
	388	if (FOLD (c) == fn)
	389	goto matched;
c627d613	390
9dce9b45 DD	391	cold = c;
9dce9b45 DD	392	c = *p++;
c627d613	393
9dce9b45 DD	394	if (c == '-' && *p != ']')
	395	{
	396	/* It is a range. */
	397	unsigned char cend = *p++;
	398	if (!(flags & FNM_NOESCAPE) && cend == '\\')
	399	cend = *p++;
	400	if (cend == '\0')
	401	return FNM_NOMATCH;
c627d613	402
9dce9b45 DD	403	if (cold <= fn && fn <= FOLD (cend))
9dce9b45 DD	404	goto matched;
c627d613	405
9dce9b45 DD	406	c = *p++;
9dce9b45 DD	407	}
c627d613 AT	408	}
c627d613 AT	409
c627d613 AT	410	if (c == ']')
	411	break;
	412	}
9dce9b45	413
c627d613 AT	414	if (!not)
	415	return FNM_NOMATCH;
	416	break;
	417
9dce9b45	418	matched:
c627d613 AT	419	/* Skip the rest of the [...] that already matched. */
	420	while (c != ']')
	421	{
	422	if (c == '\0')
	423	/* [... (unterminated) loses. */
	424	return FNM_NOMATCH;
	425
	426	c = *p++;
	427	if (!(flags & FNM_NOESCAPE) && c == '\\')
9dce9b45 DD	428	{
	429	if (*p == '\0')
	430	return FNM_NOMATCH;
	431	/* XXX 1003.2d11 is unclear if this is right. */
	432	++p;
	433	}
	434	else if (c == '[' && *p == ':')
	435	{
	436	do
	437	if (*++p == '\0')
	438	return FNM_NOMATCH;
	439	while (*p != ':' \|\| p[1] == ']');
	440	p += 2;
	441	c = *p;
	442	}
c627d613 AT	443	}
	444	if (not)
	445	return FNM_NOMATCH;
	446	}
	447	break;
	448
	449	default:
9dce9b45	450	if (c != FOLD ((unsigned char) *n))
c627d613 AT	451	return FNM_NOMATCH;
	452	}
	453
	454	++n;
	455	}
	456
	457	if (*n == '\0')
	458	return 0;
	459
	460	if ((flags & FNM_LEADING_DIR) && *n == '/')
	461	/* The FNM_LEADING_DIR flag says that "foo" matches "foobar/frobozz". /
	462	return 0;
	463
	464	return FNM_NOMATCH;
9dce9b45 DD	465
9dce9b45 DD	466	# undef FOLD
c627d613 AT	467	}
c627d613 AT	468
9dce9b45 DD	469
	470	int
	471	fnmatch (pattern, string, flags)
	472	const char *pattern;
	473	const char *string;
	474	int flags;
	475	{
	476	return internal_fnmatch (pattern, string, flags & FNM_PERIOD, flags);
	477	}
	478
	479	#endif /* _LIBC or not __GNU_LIBRARY__. */
	480	/* ----- END glibc-2.1.2 posix/fnmatch.c */
	481
c627d613 AT	482	#else /* HAVE_FNMATCH */
	483	void fnmatch_dummy(void) {}
	484	#endif