extern int  gnu_fnmatch ( const char * __pattern , const char * __name ,
		    int __flags);



  

#ident	"@(#)unixsrc:usr/src/common/head/alloca.h /main/1"

typedef unsigned int size_t;

	void *alloca(size_t);  

  

#ident	"@(#)unixsrc:usr/src/common/head/assert.h /main/1"




extern void __xassert(const char *, const char *, const char *, int);



  

#ident	"@(#)unixsrc:usr/src/common/head/ctype.h /main/1"



extern unsigned char	__ctype[];

extern int	isalnum(int);
extern int	isalpha(int);
extern int	isblank(int);
extern int	iscntrl(int);
extern int	isdigit(int);
extern int	isgraph(int);
extern int	islower(int);
extern int	isprint(int);
extern int	ispunct(int);
extern int	isspace(int);
extern int	isupper(int);
extern int	isxdigit(int);
extern int	tolower(int);
extern int	toupper(int);

extern int	isascii(int);
extern int	toascii(int);
extern int	_tolower(int);
extern int	_toupper(int);






  

#ident	"@(#)unixsrc:usr/src/common/head/errno.h /main/1"


#ident	"@(#)unixsrc:usr/src/common/uts/svc/errno.h /main/1"
#ident	"$Header: $"


 

 


 


 



 

 

 
	 
	 
 

 

 
 
 


 

 

 



extern int	errno;



  

#ident	"@(#)unixsrc:usr/src/common/head/stddef.h /main/legend/1"

typedef long 	ptrdiff_t;



	typedef long	wchar_t;


 


 

 


 

 

 

 

  

#ident	"@(#)unixsrc:usr/src/i386/head/stdlib.h /main/1"

typedef	struct
{
	int	quot;
	int	rem;
} div_t;

typedef struct
{
	long	quot;
	long	rem;
} ldiv_t;


typedef int ssize_t;








extern unsigned char	__ctype[];


extern double	atof(const char *);
extern int	atoi(const char *);
extern long	atol(const char *);
extern double	strtod(const char *, char **);
	 
extern float	strtof(const char *, char **);
extern long	strtol(const char *, char **, int);
long double	strtold(const char *, char **);
long long	strtoll(const char *, char **, int);
unsigned long	strtoul(const char *, char **, int);
unsigned long long strtoull(const char *, char **, int);

extern int	rand(void);
extern void	srand(unsigned int);

extern void	*calloc(size_t, size_t);
extern void	free(void *);
extern void	*malloc(size_t);
extern void	*realloc(void *, size_t);

extern void	_Exit(int);
extern void	abort(void);
extern int	atexit(void (*)(void));
extern void	exit(int);
extern char	*getenv(const char *);
extern int	system(const char *);

extern void	*bsearch(const void *, const void *, size_t, size_t,
			int (*)(const void *, const void *));
extern void	qsort(void *, size_t, size_t,
			int (*)(const void *, const void *));

extern int	abs(int);
extern div_t	div(int, int);
extern long	labs(long);
extern ldiv_t	ldiv(long, long);

extern int	mbtowc(wchar_t *, const char *, size_t);
extern int	mblen(const char *, size_t);
extern int	wctomb(char *, wchar_t);

extern size_t	mbstowcs(wchar_t *, const char *, size_t);
extern size_t	wcstombs(char *, const wchar_t *, size_t);


extern double	drand48(void);
extern double	erand48(unsigned short *);
extern long	jrand48(unsigned short *);
extern void	lcong48(unsigned short *);
extern long	lrand48(void);
extern long	mrand48(void);
extern long	nrand48(unsigned short *);
extern int	putenv(char *);
unsigned short	*seed48(unsigned short *);
extern void	setkey(const char *);
extern void	srand48(long);



extern long	a64l(const char *);
extern char	*ecvt(double, int, int *, int *);
extern char	*fcvt(double, int, int *, int *);
extern char	*gcvt(double, int, char *);
extern int	getsubopt(char **, char *const *, char **);
extern int	grantpt(int);
extern char	*initstate(unsigned, char * , int);
extern char	*l64a(long);
extern int	mkstemp(char *);
extern char	*mktemp(char *);
extern char	*ptsname(int);
extern long	random(void);
extern char	*realpath(const char *, char *);
extern char	*setstate(char *);
extern void	srandom(unsigned);
extern int	ttyslot(void);
extern int	unlockpt(int);
extern void	*valloc(size_t);



extern int	rand_r(unsigned int *);



typedef struct  
{
	long long	quot;
	long long	rem;
} lldiv_t;

struct mallinfo {
	size_t	arena;		 
	size_t	ordblks;	 
	size_t	smblks;		 
	size_t	hblks;		 
	size_t	hblkhd;		 
	size_t	usmblks;	 
	size_t	fsmblks;	 
	size_t	uordblks;	 
	size_t	fordblks;	 
	size_t	keepcost;	 
};

long long	atoll(const char *);  
extern int	dup2(int, int);
extern char	*ecvtl(long double, int, int *, int *);
extern char	*fcvtl(long double, int, int *, int *);
extern char	*gcvtl(long double, int, char *);
extern char	*getcwd(char *, size_t);
extern char	*getlogin(void);
extern int	getopt(int, char *const *, const char *);
extern char	*optarg;
extern int	optind, opterr, optopt;
extern char	*getpass(const char *);
extern int	getpw(int, char *);
extern int	isatty(int);
extern void	l3tol(long *, const char *, int);
extern char	*l64a_r(long, char *, size_t);
long long	llabs(long long);  
extern lldiv_t	lldiv(long long, long long);  
extern void	ltol3(char *, const long *, int);
struct mallinfo	mallinfo(void);
extern void	*memalign(size_t, size_t);
extern void	swab(const void *, void *, ssize_t);
extern char	*ttyname(int);
extern double	wcstod(const wchar_t *, wchar_t **);
	 
extern float	wcstof(const wchar_t *, wchar_t **);
extern long	wcstol(const wchar_t *, wchar_t **, int);
long double	wcstold(const wchar_t *, wchar_t **);
long long	wcstoll(const wchar_t *, wchar_t **, int);
unsigned long	wcstoul(const wchar_t *, wchar_t **, int);
unsigned long long wcstoull(const wchar_t *, wchar_t **, int);
extern int	_xgetlogin_r(char *, size_t);
extern int	_xttyname_r(int, char *, size_t);


static int
getlogin_r(char *__1, size_t __2)
{
	return _xgetlogin_r(__1, __2);
}

static int
ttyname_r(int __1, char *__2, size_t __3)
{
	return _xttyname_r(__1, __2, __3);
}




  

#ident	"@(#)unixsrc:usr/src/i386/head/string.h /main/1"




extern void	*memcpy(void *, const void *, size_t);
extern void	*memccpy(void *, const void *, int, size_t);
extern void	*memmove(void *, const void *, size_t);
extern void	*memset(void *, int, size_t);

extern char	*strcpy(char *, const char *);
extern char	*strdup(const char *);
extern char	*strncpy(char *, const char *, size_t);
extern char	*strcat(char *, const char *);
extern char	*strncat(char *, const char *, size_t);
extern char	*strtok(char *, const char *);
extern char	*strtok_r(char *, const char *, char **);
extern char	*strerror(int);
extern char	*strlist(char *, const char *, ...);
extern char	*strsignal(int);

extern int	memcmp(const void *, const void *, size_t);
extern int	strcmp(const char *, const char *);
extern int	strcoll(const char *, const char *);
extern int	strncmp(const char *, const char *, size_t);

extern size_t	strxfrm(char *, const char *, size_t);
extern size_t	strcspn(const char *, const char *);
extern size_t	strspn(const char *, const char *);
extern size_t	strlen(const char *);

extern char	*strcadd(char *, const char *);
extern char	*strccpy(char *, const char *);
extern char	*streadd(char *, const char *, const char *);
extern char	*strecpy(char *, const char *, const char *);
extern int	strfind(const char *, const char *);
extern char	*strtrns(const char *, const char *, const char *, char *);

extern size_t	strlcat(char *, const char *, size_t);
extern size_t	strlcpy(char *, const char *, size_t);

extern int	ffs(int);


extern void	*memchr(const void *, int, size_t);
extern char	*strchr(const char *, int);
extern char	*strpbrk(const char *, const char *);
extern char	*strrchr(const char *, int);
extern char	*strrspn(const char *, const char *);
extern char	*strstr(const char *, const char *);




 
 
  

#ident	"@(#)unixsrc:usr/src/common/head/wchar.h /main/3"


typedef unsigned long	wuchar_t;


typedef long	wint_t;

typedef struct
{
	unsigned char	__rule[4];
	wchar_t		__mbwc;
	wchar_t		__mbst;
} mbstate_t;

struct _FILE_;		 
struct tm;		 






extern wint_t	fgetwc(struct _FILE_ *);
extern wchar_t	*fgetws(wchar_t *, int, struct _FILE_ *);
extern wint_t	fputwc(wchar_t, struct _FILE_ *);
extern int	fputws(const wchar_t *, struct _FILE_ *);
extern wint_t	getwc(struct _FILE_ *);
extern wint_t	getwchar(void);
extern wint_t	putwc(wchar_t, struct _FILE_ *);
extern wint_t	putwchar(wchar_t);
extern wint_t	ungetwc(wint_t, struct _FILE_ *);

extern wchar_t	*wcscat(wchar_t *, const wchar_t *);
extern int	wcscmp(const wchar_t *, const wchar_t *);
extern int	wcscoll(const wchar_t *, const wchar_t *);
extern size_t	wcsxfrm(wchar_t *, const wchar_t *, size_t);
extern wchar_t	*wcscpy(wchar_t *, const wchar_t *);
extern size_t	wcscspn(const wchar_t *, const wchar_t *);
extern size_t	wcslen(const wchar_t *);
extern wchar_t	*wcsncat(wchar_t *, const wchar_t *, size_t);
extern int	wcsncmp(const wchar_t *, const wchar_t *, size_t);
extern wchar_t	*wcsncpy(wchar_t *, const wchar_t *, size_t);
extern size_t	wcsspn(const wchar_t *, const wchar_t *);
extern wchar_t	*_wcstok(wchar_t *, const wchar_t *, wchar_t **);

extern double	wcstod(const wchar_t *, wchar_t **);
	 
extern float	wcstof(const wchar_t *, wchar_t **);
extern long	wcstol(const wchar_t *, wchar_t **, int);
long double	wcstold(const wchar_t *, wchar_t **);
long long	wcstoll(const wchar_t *, wchar_t **, int);
unsigned long	wcstoul(const wchar_t *, wchar_t **, int);
unsigned long long wcstoull(const wchar_t *, wchar_t **, int);
extern int	wcswidth(const wchar_t *, size_t);


extern size_t	wcsftime(wchar_t *, size_t, const wchar_t *, const struct tm *);

extern wchar_t	*wcstok(wchar_t *, const wchar_t *, wchar_t **);

extern int	fwide(struct _FILE_ *, int);
		 
extern int	fwprintf(struct _FILE_ *, const wchar_t *, ...);
		 
extern int	fwscanf(struct _FILE_ *, const wchar_t *, ...);
		 
extern int	wprintf(const wchar_t *, ...);
		 
extern int	wscanf(const wchar_t *, ...);
		 
extern int	swprintf(wchar_t *, size_t, const wchar_t *, ...);
		 
extern int	swscanf(const wchar_t *, const wchar_t *, ...);
extern int	vfwprintf(struct _FILE_ *, const wchar_t *,  void * ) ;
extern int	vwprintf(const wchar_t *,  void * ) ;
extern int	vswprintf(wchar_t *, size_t, const wchar_t *,  void * ) ;

extern wint_t	btowc(int);
extern int	wctob(wint_t);
extern size_t	mbrlen(const char *, size_t, mbstate_t *);
extern size_t	mbrtowc(wchar_t *, const char *, size_t, mbstate_t *);
extern size_t	wcrtomb(char *, wchar_t, mbstate_t *);
extern size_t	mbsrtowcs(wchar_t *, const char **, size_t, mbstate_t *);
extern size_t	wcsrtombs(char *, const wchar_t **, size_t, mbstate_t *);
extern int	mbsinit(const mbstate_t *);


extern int	wmemcmp(const wchar_t *, const wchar_t *, size_t);
extern wchar_t	*wmemcpy(wchar_t *, const wchar_t *, size_t);
extern wchar_t	*wmemmove(wchar_t *, const wchar_t *, size_t);
extern wchar_t	*wmemset(wchar_t *, wchar_t, size_t);


extern int	mbswidth(const char *, size_t);
extern int	wcwidth(wchar_t);
extern int	vfwscanf(struct _FILE_ *, const wchar_t *,  void * ) ;
extern int	vwscanf(const wchar_t *,  void * ) ;
extern int	vswscanf(const wchar_t *, const wchar_t *,  void * ) ;


extern wchar_t	*wcschr(const wchar_t *, wchar_t);
extern wchar_t	*wcspbrk(const wchar_t *, const wchar_t *);
extern wchar_t	*wcsrchr(const wchar_t *, wchar_t);
extern wchar_t	*wcsstr(const wchar_t *, const wchar_t *);
extern wchar_t	*wcswcs(const wchar_t *, const wchar_t *);  

extern wchar_t	*wmemchr(const wchar_t *, wchar_t, size_t);


  

#ident	"@(#)unixsrc:usr/src/common/head/wctype.h /main/1"


typedef unsigned long	wctype_t;

typedef unsigned long	wctrans_t;





extern unsigned char	__ctype[];

extern int	iswalnum(wint_t);
extern int	iswalpha(wint_t);
extern int	iswblank(wint_t);
extern int	iswcntrl(wint_t);
extern int	iswdigit(wint_t);
extern int	iswgraph(wint_t);
extern int	iswlower(wint_t);
extern int	iswprint(wint_t);
extern int	iswpunct(wint_t);
extern int	iswspace(wint_t);
extern int	iswupper(wint_t);
extern int	iswxdigit(wint_t);

extern wctype_t	wctype(const char *);
extern int	iswctype(wint_t, wctype_t);

extern wint_t	towlower(wint_t);
extern wint_t	towupper(wint_t);

wctrans_t	wctrans(const char *);
extern wint_t	towctrans(wint_t, wctrans_t);

extern int	__iswctype(wint_t, wctype_t);
extern wint_t	__trwctype(wint_t, wctrans_t);

	 





static wint_t __wc;  








 


 

 







 
 



 


 

 
static int posixly_correct;

 

 
 

 
static int  ext_match ( int opt , const char * pattern , const char * string ,
		const  char * string_end , _Bool no_leading_period , int flags )
      ;
static const  char * end_pattern ( const char * patternp ) ;

static int

 internal_fnmatch ( const char * pattern , const char * string , const char * string_end ,
      _Bool no_leading_period , int flags )
{
  register const  char * p = pattern , * n = string ;
  register  unsigned char c ;

  while ((c = *p++) !=  '\0' )
    {
       _Bool new_no_leading_period = 0 ;
      c =  ( ( flags & ( 1 << 4 ) ) && ( 1 && ( ( __ctype + 1 ) [ c ] & 01 ) ) ? tolower ( c ) : ( c ) ) ;

      switch (c)
	{
	case  '?' :
	  if ( ( flags & ( 1 << 5 ) ) && * p == '(' )
	    {
	      int res;

	      res =  ext_match ( c , p , n , string_end , no_leading_period ,
			 flags);
	      if (res != -1)
		return res;
	    }

	  if (n == string_end)
	    return  1 ;
	  else if (*n ==  '/' && ( flags & ( 1 << 0 ) ) )
	    return  1 ;
	  else if (*n ==  '.' && no_leading_period )
	    return  1 ;
	  break;

	case  '\\' :
	  if (!(flags &  ( 1 << 1 ) ) )
	    {
	      c = *p++;
	      if (c ==  '\0' )
		 
		return  1 ;
	      c =  ( ( flags & ( 1 << 4 ) ) && ( 1 && ( ( __ctype + 1 ) [ c ] & 01 ) ) ? tolower ( c ) : ( c ) ) ;
	    }
	  if (n == string_end ||  ( ( flags & ( 1 << 4 ) ) && ( 1 && ( ( __ctype + 1 ) [ ( unsigned char ) * n ] & 01 ) ) ? tolower ( ( unsigned char ) * n ) : ( ( unsigned char ) * n ) ) != c )
	    return  1 ;
	  break;

	case  '*' :
	  if ( ( flags & ( 1 << 5 ) ) && * p == '(' )
	    {
	      int res;

	      res =  ext_match ( c , p , n , string_end , no_leading_period ,
			 flags);
	      if (res != -1)
		return res;
	    }

	  if (n != string_end && *n ==  '.' && no_leading_period )
	    return  1 ;

	  for (c = *p++; c ==  '?' || c == '*' ; c = * p ++ )
	    {
	      if (*p ==  '(' && ( flags & ( 1 << 5 ) ) != 0 )
		{
		  const  char * endp = end_pattern ( p ) ;
		  if (endp != p)
		    {
		       
		      p = endp;
		      continue;
		    }
		}

	      if (c ==  '?' )
		{
		   
		  if (n == string_end)
		     
		    return  1 ;
		  else if (*n ==  '/'
			   &&  ( flags & ( 1 << 0 ) ) )
		     
		    return  1 ;
		  else
		     
		    ++n;
		}
	    }

	  if (c ==  '\0' )
	     
	    {
	      int result = (flags &  ( 1 << 0 ) ) == 0 ? 0 : 1 ;

	      if (flags &  ( 1 << 0 ) )
		{
		  if (flags &  ( 1 << 3 ) )
		    result = 0;
		  else
		    {
		      if ( memchr ( n , '/' , string_end - n ) == 0 )
			result = 0;
		    }
		}

	      return result;
	    }
	  else
	    {
	      const  char * endp ;

	      endp =  memchr ( n , ( flags & ( 1 << 0 ) ) ? '/' : '\0' , string_end - n ) ;
	      if (endp ==  0 )
		endp = string_end;

	      if (c ==  '['
		  || ( ( flags & ( 1 << 5 ) ) != 0
		      && (c ==  '@' || c == '+' || c == '!' )
		      && *p ==  '(' ) )
		{
		  int flags2 = ((flags &  ( 1 << 0 ) )
				? flags : (flags & ~ ( 1 << 2 ) ) ) ;
		   _Bool no_leading_period2 = no_leading_period ;

		  for (--p; n < endp; ++n, no_leading_period2 =  0 )
		    if ( internal_fnmatch ( p , n , string_end , no_leading_period2 , flags2 )
			== 0)
		      return 0;
		}
	      else if (c ==  '/' && ( flags & ( 1 << 0 ) ) )
		{
		  while (n < string_end && *n !=  '/' )
		    ++n;
		  if (n < string_end && *n ==  '/'
		      && ( internal_fnmatch ( p , n + 1 , string_end , flags & ( 1 << 2 ) , flags )
			  == 0))
		    return 0;
		}
	      else
		{
		  int flags2 = ((flags &  ( 1 << 0 ) )
				? flags : (flags & ~ ( 1 << 2 ) ) ) ;
		  int no_leading_period2 = no_leading_period;

		  if (c ==  '\\' && ! ( flags & ( 1 << 1 ) ) )
		    c = *p;
		  c =  ( ( flags & ( 1 << 4 ) ) && ( 1 && ( ( __ctype + 1 ) [ c ] & 01 ) ) ? tolower ( c ) : ( c ) ) ;
		  for (--p; n < endp; ++n, no_leading_period2 =  0 )
		    if ( ( ( flags & ( 1 << 4 ) ) && ( 1 && ( ( __ctype + 1 ) [ ( unsigned char ) * n ] & 01 ) ) ? tolower ( ( unsigned char ) * n ) : ( ( unsigned char ) * n ) ) == c
			&& ( internal_fnmatch ( p , n , string_end , no_leading_period2 , flags2 )
			    == 0))
		      return 0;
		}
	    }

	   
	  return  1 ;

	case  '[' :
	  {
	     
	    register  _Bool not ;
	     char cold ;
	     unsigned char fn ;

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

	    if (n == string_end)
	      return  1 ;

	    if (*n ==  '.' && no_leading_period )
	      return  1 ;

	    if (*n ==  '/' && ( flags & ( 1 << 0 ) ) )
	       
	      return  1 ;

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

	    fn =  ( ( flags & ( 1 << 4 ) ) && ( 1 && ( ( __ctype + 1 ) [ ( unsigned char ) * n ] & 01 ) ) ? tolower ( ( unsigned char ) * n ) : ( ( unsigned char ) * n ) ) ;

	    c = *p++;
	    for (;;)
	      {
		if (!(flags &  ( 1 << 1 ) ) && c == '\\' )
		  {
		    if (*p ==  '\0' )
		      return  1 ;
		    c =  ( ( flags & ( 1 << 4 ) ) && ( 1 && ( ( __ctype + 1 ) [ ( unsigned char ) * p ] & 01 ) ) ? tolower ( ( unsigned char ) * p ) : ( ( unsigned char ) * p ) ) ;
		    ++p;

		    if (c == fn)
		      goto matched;
		  }
		else if (c ==  '[' && * p == ':' )
		  {
		     
		     char str [ 256 + 1 ] ;
		    size_t c1 = 0;
		    wctype_t wt;
		    const  char * startp = p ;

		    for (;;)
		      {
			if (c1 ==  256 )
			   
			  return  1 ;

			c = *++p;
			if (c ==  ':' && p [ 1 ] == ']' )
			  {
			    p += 2;
			    break;
			  }
			if (c <  'a' || c >= 'z' )
			  {
			     
			    p = startp;
			    c =  '[' ;
			    goto normal_bracket;
			  }
			str[c1++] = c;
		      }
		    str[c1] =  '\0' ;

		    wt =  wctype ( str ) ;
		    if (wt == 0)
		       
		      return  1 ;

		    if ( iswctype ( btowc ( ( unsigned char ) * n ) , wt ) )
		      goto matched;
		    c = *p++;
		  }
		else if (c ==  '\0' )
		   
		  return  1 ;
		else
		  {
		     _Bool is_range = 0 ;

		      {
			c =  ( ( flags & ( 1 << 4 ) ) && ( 1 && ( ( __ctype + 1 ) [ c ] & 01 ) ) ? tolower ( c ) : ( c ) ) ;
		      normal_bracket:

			 
			is_range = (*p ==  '-' && p [ 1 ] != '\0'
				    && p[1] !=  ']' ) ;

			if (!is_range && c == fn)
			  goto matched;

			cold = c;
			c = *p++;
		      }

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

			if (!(flags &  ( 1 << 1 ) ) && cend == '\\' )
			  cend = *p++;
			if (cend ==  '\0' )
			  return  1 ;

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

			c = *p++;
		      }
		  }

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

	    if (!not)
	      return  1 ;
	    break;

	  matched:
	     
	    do
	      {
	      ignore_next:
		c = *p++;

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

		if (!(flags &  ( 1 << 1 ) ) && c == '\\' )
		  {
		    if (*p ==  '\0' )
		      return  1 ;
		     
		    ++p;
		  }
		else if (c ==  '[' && * p == ':' )
		  {
		    int c1 = 0;
		    const  char * startp = p ;

		    while (1)
		      {
			c = *++p;
			if (++c1 ==  256 )
			  return  1 ;

			if (*p ==  ':' && p [ 1 ] == ']' )
			  break;

			if (c <  'a' || c >= 'z' )
			  {
			    p = startp;
			    goto ignore_next;
			  }
		      }
		    p += 2;
		    c = *p++;
		  }
		else if (c ==  '[' && * p == '=' )
		  {
		    c = *++p;
		    if (c ==  '\0' )
		      return  1 ;
		    c = *++p;
		    if (c !=  '=' || p [ 1 ] != ']' )
		      return  1 ;
		    p += 2;
		    c = *p++;
		  }
		else if (c ==  '[' && * p == '.' )
		  {
		    ++p;
		    while (1)
		      {
			c = *++p;
			if (c == '\0')
			  return  1 ;

			if (*p ==  '.' && p [ 1 ] == ']' )
			  break;
		      }
		    p += 2;
		    c = *p++;
		  }
	      }
	    while (c !=  ']' ) ;
	    if (not)
	      return  1 ;
	  }
	  break;

	case  '+' :
	case  '@' :
	case  '!' :
	  if ( ( flags & ( 1 << 5 ) ) && * p == '(' )
	    {
	      int res;

	      res =  ext_match ( c , p , n , string_end , no_leading_period , flags ) ;
	      if (res != -1)
		return res;
	    }
	  goto normal_match;

	case  '/' :
	  if ( ( ( flags & ( ( 1 << 0 ) | ( 1 << 2 ) ) ) == ( ( 1 << 0 ) | ( 1 << 2 ) ) ) )
	    {
	      if (n == string_end || c != ( unsigned char ) * n )
		return  1 ;

	      new_no_leading_period =  1 ;
	      break;
	    }
	   
	default:
	normal_match:
	  if (n == string_end || c !=  ( ( flags & ( 1 << 4 ) ) && ( 1 && ( ( __ctype + 1 ) [ ( unsigned char ) * n ] & 01 ) ) ? tolower ( ( unsigned char ) * n ) : ( ( unsigned char ) * n ) ) )
	    return  1 ;
	}

      no_leading_period = new_no_leading_period;
      ++n;
    }

  if (n == string_end)
    return 0;

  if ((flags &  ( 1 << 3 ) ) && n != string_end && * n == '/' )
     
    return 0;

  return  1 ;
}


static const  char *

 end_pattern ( const char * pattern )
{
  const  char * p = pattern ;

  while (1)
    if (*++p ==  '\0' )
       
      return pattern;
    else if (*p ==  '[' )
      {
	 
	if (posixly_correct == 0)
	  posixly_correct = getenv ("POSIXLY_CORRECT") !=  0 ? 1 : - 1 ;

	 
	if (*++p ==  '!' || ( posixly_correct < 0 && * p == '^' ) )
	  ++p;
	 
	if (*p ==  ']' )
	  ++p;
	 
	while (*p !=  ']' )
	  if (*p++ ==  '\0' )
	     
	    return pattern;
      }
    else if ((*p ==  '?' || * p == '*' || * p == '+' || * p == '@'
	      || *p ==  '!' ) && p [ 1 ] == '(' )
      p =  end_pattern ( p + 1 ) ;
    else if (*p ==  ')' )
      break;

  return p + 1;
}


static int

 ext_match ( int opt , const char * pattern , const char * string , const char * string_end ,
      _Bool no_leading_period , int flags )
{
  const  char * startp ;
  size_t level;
  struct patternlist
  {
    struct patternlist *next;
     char str [ 1 ] ;
  } *list =  0 ;
  struct patternlist **lastp = &list;
  size_t pattern_len =  strlen ( pattern ) ;
  const  char * p ;
  const  char * rs ;
  enum { ALLOCA_LIMIT = 8000 };

   
  level = 0;
  for (startp = p = pattern + 1; ; ++p)
    if (*p ==  '\0' )
       
      return -1;
    else if (*p ==  '[' )
      {
	 
	if (posixly_correct == 0)
	  posixly_correct = getenv ("POSIXLY_CORRECT") !=  0 ? 1 : - 1 ;

	 
	if (*++p ==  '!' || ( posixly_correct < 0 && * p == '^' ) )
	  ++p;
	 
	if (*p ==  ']' )
	  ++p;
	 
	while (*p !=  ']' )
	  if (*p++ ==  '\0' )
	     
	    return -1;
      }
    else if ((*p ==  '?' || * p == '*' || * p == '+' || * p == '@'
	      || *p ==  '!' ) && p [ 1 ] == '(' )
       
      ++level;
    else if (*p ==  ')' )
      {
	if (level-- == 0)
	  {
	     
	     struct patternlist * newp ; size_t plen ; size_t plensize ; size_t newpsize ; plen = ( opt == '?' || opt == '@' ? pattern_len : p - startp + 1 ) ; plensize = plen * sizeof ( char ) ; newpsize = ( size_t ) ( & ( ( ( struct patternlist * ) 0 ) -> str ) ) + plensize ; if ( ( size_t ) - 1 / sizeof ( char ) < plen || newpsize < ( size_t ) ( & ( ( ( struct patternlist * ) 0 ) -> str ) ) || ALLOCA_LIMIT <= newpsize ) return - 1 ; newp = ( struct patternlist * ) alloca ( newpsize ) ; * ( ( char * ) ( ( void * ) ( ( char * ) memcpy ( newp -> str , startp , p - startp ) + ( p - startp ) ) ) ) = '\0' ; newp -> next = 0 ; * lastp = newp ; lastp = & newp -> next ;
	    break;
	  }
      }
    else if (*p ==  '|' )
      {
	if (level == 0)
	  {
	     struct patternlist * newp ; size_t plen ; size_t plensize ; size_t newpsize ; plen = ( opt == '?' || opt == '@' ? pattern_len : p - startp + 1 ) ; plensize = plen * sizeof ( char ) ; newpsize = ( size_t ) ( & ( ( ( struct patternlist * ) 0 ) -> str ) ) + plensize ; if ( ( size_t ) - 1 / sizeof ( char ) < plen || newpsize < ( size_t ) ( & ( ( ( struct patternlist * ) 0 ) -> str ) ) || ALLOCA_LIMIT <= newpsize ) return - 1 ; newp = ( struct patternlist * ) alloca ( newpsize ) ; * ( ( char * ) ( ( void * ) ( ( char * ) memcpy ( newp -> str , startp , p - startp ) + ( p - startp ) ) ) ) = '\0' ; newp -> next = 0 ; * lastp = newp ; lastp = & newp -> next ;
	    startp = p + 1;
	  }
      }
   ( ( void ) ( ( list != 0 ) || ( __xassert ( "list != NULL" , __func__ , "./fnmatch_loop.c" , 1080 ) , 0 ) ) ) ;
   ( ( void ) ( ( p [ - 1 ] == ')' ) || ( __xassert ( "p[-1] == L(')')" , __func__ , "./fnmatch_loop.c" , 1081 ) , 0 ) ) ) ;

  switch (opt)
    {
    case  '*' :
      if ( internal_fnmatch ( p , string , string_end , no_leading_period , flags ) == 0 )
	return 0;
       

    case  '+' :
      do
	{
	  for (rs = string; rs <= string_end; ++rs)
	     
	    if ( internal_fnmatch ( list -> str , string , rs , no_leading_period ,
		     flags &  ( 1 << 0 ) ? flags : flags & ~ ( 1 << 2 ) ) == 0
		 
		&& ( internal_fnmatch ( p , rs , string_end ,
			 rs == string
			 ? no_leading_period
			 : rs[-1] == '/' &&  ( ( flags & ( ( 1 << 0 ) | ( 1 << 2 ) ) ) == ( ( 1 << 0 ) | ( 1 << 2 ) ) ) ,
			 flags &  ( 1 << 0 )
			 ? flags : flags & ~ ( 1 << 2 ) ) == 0
		     
		    || (rs != string
			&&  internal_fnmatch ( pattern - 1 , rs , string_end ,
				rs == string
				? no_leading_period
				: rs[-1] == '/' &&  ( ( flags & ( ( 1 << 0 ) | ( 1 << 2 ) ) ) == ( ( 1 << 0 ) | ( 1 << 2 ) ) ) ,
				flags &  ( 1 << 0 )
				? flags : flags & ~ ( 1 << 2 ) ) == 0 ) ) )
	       
	      return 0;
	}
      while ((list = list->next) !=  0 ) ;

       
      return  1 ;

    case  '?' :
      if ( internal_fnmatch ( p , string , string_end , no_leading_period , flags ) == 0 )
	return 0;
       

    case  '@' :
      do
	 
	if ( internal_fnmatch ( strcat ( list -> str , p ) , string , string_end ,
		 no_leading_period,
		 flags &  ( 1 << 0 ) ? flags : flags & ~ ( 1 << 2 ) ) == 0 )
	   
	  return 0;
      while ((list = list->next) !=  0 ) ;

       
      return  1 ;

    case  '!' :
      for (rs = string; rs <= string_end; ++rs)
	{
	  struct patternlist *runp;

	  for (runp = list; runp !=  0 ; runp = runp -> next )
	    if ( internal_fnmatch ( runp -> str , string , rs ,  no_leading_period ,
		     flags &  ( 1 << 0 ) ? flags : flags & ~ ( 1 << 2 ) ) == 0 )
	      break;

	   
	  if (runp ==  0
	      && ( internal_fnmatch ( p , rs , string_end ,
		       rs == string
		       ? no_leading_period
		       : rs[-1] == '/' &&  ( ( flags & ( ( 1 << 0 ) | ( 1 << 2 ) ) ) == ( ( 1 << 0 ) | ( 1 << 2 ) ) ) ,
		       flags &  ( 1 << 0 ) ? flags : flags & ~ ( 1 << 2 ) )
		  == 0))
	     
	    return 0;
	}

       
      return  1 ;

    default:
       ( ( void ) ( ( ! "Invalid extended matching operator" ) || ( __xassert ( "! \"Invalid extended matching operator\"" , __func__ , "./fnmatch_loop.c" , 1171 ) , 0 ) ) ) ;
      break;
    }

  return -1;
}





 
static wctype_t
is_char_class (const wchar_t *wcs)
{
  char s[ 256 + 1 ] ;
  char *cp = s;

  do
    {
       
      switch (*wcs)
	{
	case L' ': case L'!': case L'"': case L'#': case L'%':
	case L'&': case L'\'': case L'(': case L')': case L'*':
	case L'+': case L',': case L'-': case L'.': case L'/':
	case L'0': case L'1': case L'2': case L'3': case L'4':
	case L'5': case L'6': case L'7': case L'8': case L'9':
	case L':': case L';': case L'<': case L'=': case L'>':
	case L'?':
	case L'A': case L'B': case L'C': case L'D': case L'E':
	case L'F': case L'G': case L'H': case L'I': case L'J':
	case L'K': case L'L': case L'M': case L'N': case L'O':
	case L'P': case L'Q': case L'R': case L'S': case L'T':
	case L'U': case L'V': case L'W': case L'X': case L'Y':
	case L'Z':
	case L'[': case L'\\': case L']': case L'^': case L'_':
	case L'a': case L'b': case L'c': case L'd': case L'e':
	case L'f': case L'g': case L'h': case L'i': case L'j':
	case L'k': case L'l': case L'm': case L'n': case L'o':
	case L'p': case L'q': case L'r': case L's': case L't':
	case L'u': case L'v': case L'w': case L'x': case L'y':
	case L'z': case L'{': case L'|': case L'}': case L'~':
	  break;
	default:
	  return (wctype_t) 0;
	}

       
      if (cp == s +  256 )
	return (wctype_t) 0;

      *cp++ = (char) *wcs++;
    }
  while (*wcs != L'\0');

  *cp = '\0';

  return wctype (s);
}

 

 
static int  ext_wmatch ( wint_t opt , const wchar_t * pattern , const wchar_t * string ,
		const  wchar_t * string_end , _Bool no_leading_period , int flags )
      ;
static const  wchar_t * end_wpattern ( const wchar_t * patternp ) ;

static int

 internal_fnwmatch ( const wchar_t * pattern , const wchar_t * string , const wchar_t * string_end ,
      _Bool no_leading_period , int flags )
{
  register const  wchar_t * p = pattern , * n = string ;
  register  wint_t c ;

  while ((c = *p++) !=  L'\0' )
    {
       _Bool new_no_leading_period = 0 ;
      c =  ( ( flags & ( 1 << 4 ) ) ? ( ( __wc = ( c ) ) > 255 ? __trwctype ( __wc , ( 01 ) ) : ( ( ( 1 + __ctype ) [ __wc ] & ( ( 01 ) ) ) ? ( 258 + __ctype ) [ __wc ] : ( __wc ) ) ) : ( c ) ) ;

      switch (c)
	{
	case  L'?' :
	  if ( ( flags & ( 1 << 5 ) ) && * p == '(' )
	    {
	      int res;

	      res =  ext_wmatch ( c , p , n , string_end , no_leading_period ,
			 flags);
	      if (res != -1)
		return res;
	    }

	  if (n == string_end)
	    return  1 ;
	  else if (*n ==  L'/' && ( flags & ( 1 << 0 ) ) )
	    return  1 ;
	  else if (*n ==  L'.' && no_leading_period )
	    return  1 ;
	  break;

	case  L'\\' :
	  if (!(flags &  ( 1 << 1 ) ) )
	    {
	      c = *p++;
	      if (c ==  L'\0' )
		 
		return  1 ;
	      c =  ( ( flags & ( 1 << 4 ) ) ? ( ( __wc = ( c ) ) > 255 ? __trwctype ( __wc , ( 01 ) ) : ( ( ( 1 + __ctype ) [ __wc ] & ( ( 01 ) ) ) ? ( 258 + __ctype ) [ __wc ] : ( __wc ) ) ) : ( c ) ) ;
	    }
	  if (n == string_end ||  ( ( flags & ( 1 << 4 ) ) ? ( ( __wc = ( ( wint_t ) * n ) ) > 255 ? __trwctype ( __wc , ( 01 ) ) : ( ( ( 1 + __ctype ) [ __wc ] & ( ( 01 ) ) ) ? ( 258 + __ctype ) [ __wc ] : ( __wc ) ) ) : ( ( wint_t ) * n ) ) != c )
	    return  1 ;
	  break;

	case  L'*' :
	  if ( ( flags & ( 1 << 5 ) ) && * p == '(' )
	    {
	      int res;

	      res =  ext_wmatch ( c , p , n , string_end , no_leading_period ,
			 flags);
	      if (res != -1)
		return res;
	    }

	  if (n != string_end && *n ==  L'.' && no_leading_period )
	    return  1 ;

	  for (c = *p++; c ==  L'?' || c == L'*' ; c = * p ++ )
	    {
	      if (*p ==  L'(' && ( flags & ( 1 << 5 ) ) != 0 )
		{
		  const  wchar_t * endp = end_wpattern ( p ) ;
		  if (endp != p)
		    {
		       
		      p = endp;
		      continue;
		    }
		}

	      if (c ==  L'?' )
		{
		   
		  if (n == string_end)
		     
		    return  1 ;
		  else if (*n ==  L'/'
			   &&  ( flags & ( 1 << 0 ) ) )
		     
		    return  1 ;
		  else
		     
		    ++n;
		}
	    }

	  if (c ==  L'\0' )
	     
	    {
	      int result = (flags &  ( 1 << 0 ) ) == 0 ? 0 : 1 ;

	      if (flags &  ( 1 << 0 ) )
		{
		  if (flags &  ( 1 << 3 ) )
		    result = 0;
		  else
		    {
		      if ( wmemchr ( n , L'/' , string_end - n ) == 0 )
			result = 0;
		    }
		}

	      return result;
	    }
	  else
	    {
	      const  wchar_t * endp ;

	      endp =  wmemchr ( n , ( flags & ( 1 << 0 ) ) ? L'/' : L'\0' , string_end - n ) ;
	      if (endp ==  0 )
		endp = string_end;

	      if (c ==  L'['
		  || ( ( flags & ( 1 << 5 ) ) != 0
		      && (c ==  L'@' || c == L'+' || c == L'!' )
		      && *p ==  L'(' ) )
		{
		  int flags2 = ((flags &  ( 1 << 0 ) )
				? flags : (flags & ~ ( 1 << 2 ) ) ) ;
		   _Bool no_leading_period2 = no_leading_period ;

		  for (--p; n < endp; ++n, no_leading_period2 =  0 )
		    if ( internal_fnwmatch ( p , n , string_end , no_leading_period2 , flags2 )
			== 0)
		      return 0;
		}
	      else if (c ==  L'/' && ( flags & ( 1 << 0 ) ) )
		{
		  while (n < string_end && *n !=  L'/' )
		    ++n;
		  if (n < string_end && *n ==  L'/'
		      && ( internal_fnwmatch ( p , n + 1 , string_end , flags & ( 1 << 2 ) , flags )
			  == 0))
		    return 0;
		}
	      else
		{
		  int flags2 = ((flags &  ( 1 << 0 ) )
				? flags : (flags & ~ ( 1 << 2 ) ) ) ;
		  int no_leading_period2 = no_leading_period;

		  if (c ==  L'\\' && ! ( flags & ( 1 << 1 ) ) )
		    c = *p;
		  c =  ( ( flags & ( 1 << 4 ) ) ? ( ( __wc = ( c ) ) > 255 ? __trwctype ( __wc , ( 01 ) ) : ( ( ( 1 + __ctype ) [ __wc ] & ( ( 01 ) ) ) ? ( 258 + __ctype ) [ __wc ] : ( __wc ) ) ) : ( c ) ) ;
		  for (--p; n < endp; ++n, no_leading_period2 =  0 )
		    if ( ( ( flags & ( 1 << 4 ) ) ? ( ( __wc = ( ( wint_t ) * n ) ) > 255 ? __trwctype ( __wc , ( 01 ) ) : ( ( ( 1 + __ctype ) [ __wc ] & ( ( 01 ) ) ) ? ( 258 + __ctype ) [ __wc ] : ( __wc ) ) ) : ( ( wint_t ) * n ) ) == c
			&& ( internal_fnwmatch ( p , n , string_end , no_leading_period2 , flags2 )
			    == 0))
		      return 0;
		}
	    }

	   
	  return  1 ;

	case  L'[' :
	  {
	     
	    register  _Bool not ;
	     wchar_t cold ;
	     wint_t fn ;

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

	    if (n == string_end)
	      return  1 ;

	    if (*n ==  L'.' && no_leading_period )
	      return  1 ;

	    if (*n ==  L'/' && ( flags & ( 1 << 0 ) ) )
	       
	      return  1 ;

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

	    fn =  ( ( flags & ( 1 << 4 ) ) ? ( ( __wc = ( ( wint_t ) * n ) ) > 255 ? __trwctype ( __wc , ( 01 ) ) : ( ( ( 1 + __ctype ) [ __wc ] & ( ( 01 ) ) ) ? ( 258 + __ctype ) [ __wc ] : ( __wc ) ) ) : ( ( wint_t ) * n ) ) ;

	    c = *p++;
	    for (;;)
	      {
		if (!(flags &  ( 1 << 1 ) ) && c == L'\\' )
		  {
		    if (*p ==  L'\0' )
		      return  1 ;
		    c =  ( ( flags & ( 1 << 4 ) ) ? ( ( __wc = ( ( wint_t ) * p ) ) > 255 ? __trwctype ( __wc , ( 01 ) ) : ( ( ( 1 + __ctype ) [ __wc ] & ( ( 01 ) ) ) ? ( 258 + __ctype ) [ __wc ] : ( __wc ) ) ) : ( ( wint_t ) * p ) ) ;
		    ++p;

		    if (c == fn)
		      goto matched;
		  }
		else if (c ==  L'[' && * p == L':' )
		  {
		     
		     wchar_t str [ 256 + 1 ] ;
		    size_t c1 = 0;
		    wctype_t wt;
		    const  wchar_t * startp = p ;

		    for (;;)
		      {
			if (c1 ==  256 )
			   
			  return  1 ;

			c = *++p;
			if (c ==  L':' && p [ 1 ] == L']' )
			  {
			    p += 2;
			    break;
			  }
			if (c <  L'a' || c >= L'z' )
			  {
			     
			    p = startp;
			    c =  L'[' ;
			    goto normal_bracket;
			  }
			str[c1++] = c;
		      }
		    str[c1] =  L'\0' ;

		    wt =  is_char_class ( str ) ;
		    if (wt == 0)
		       
		      return  1 ;

		    if ( iswctype ( ( ( wint_t ) * n ) , wt ) )
		      goto matched;
		    c = *p++;
		  }
		else if (c ==  L'\0' )
		   
		  return  1 ;
		else
		  {
		     _Bool is_range = 0 ;

		      {
			c =  ( ( flags & ( 1 << 4 ) ) ? ( ( __wc = ( c ) ) > 255 ? __trwctype ( __wc , ( 01 ) ) : ( ( ( 1 + __ctype ) [ __wc ] & ( ( 01 ) ) ) ? ( 258 + __ctype ) [ __wc ] : ( __wc ) ) ) : ( c ) ) ;
		      normal_bracket:

			 
			is_range = (*p ==  L'-' && p [ 1 ] != L'\0'
				    && p[1] !=  L']' ) ;

			if (!is_range && c == fn)
			  goto matched;

			cold = c;
			c = *p++;
		      }

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

			if (!(flags &  ( 1 << 1 ) ) && cend == L'\\' )
			  cend = *p++;
			if (cend ==  L'\0' )
			  return  1 ;

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

			c = *p++;
		      }
		  }

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

	    if (!not)
	      return  1 ;
	    break;

	  matched:
	     
	    do
	      {
	      ignore_next:
		c = *p++;

		if (c ==  L'\0' )
		   
		  return  1 ;

		if (!(flags &  ( 1 << 1 ) ) && c == L'\\' )
		  {
		    if (*p ==  L'\0' )
		      return  1 ;
		     
		    ++p;
		  }
		else if (c ==  L'[' && * p == L':' )
		  {
		    int c1 = 0;
		    const  wchar_t * startp = p ;

		    while (1)
		      {
			c = *++p;
			if (++c1 ==  256 )
			  return  1 ;

			if (*p ==  L':' && p [ 1 ] == L']' )
			  break;

			if (c <  L'a' || c >= L'z' )
			  {
			    p = startp;
			    goto ignore_next;
			  }
		      }
		    p += 2;
		    c = *p++;
		  }
		else if (c ==  L'[' && * p == L'=' )
		  {
		    c = *++p;
		    if (c ==  L'\0' )
		      return  1 ;
		    c = *++p;
		    if (c !=  L'=' || p [ 1 ] != L']' )
		      return  1 ;
		    p += 2;
		    c = *p++;
		  }
		else if (c ==  L'[' && * p == L'.' )
		  {
		    ++p;
		    while (1)
		      {
			c = *++p;
			if (c == '\0')
			  return  1 ;

			if (*p ==  L'.' && p [ 1 ] == L']' )
			  break;
		      }
		    p += 2;
		    c = *p++;
		  }
	      }
	    while (c !=  L']' ) ;
	    if (not)
	      return  1 ;
	  }
	  break;

	case  L'+' :
	case  L'@' :
	case  L'!' :
	  if ( ( flags & ( 1 << 5 ) ) && * p == '(' )
	    {
	      int res;

	      res =  ext_wmatch ( c , p , n , string_end , no_leading_period , flags ) ;
	      if (res != -1)
		return res;
	    }
	  goto normal_match;

	case  L'/' :
	  if ( ( ( flags & ( ( 1 << 0 ) | ( 1 << 2 ) ) ) == ( ( 1 << 0 ) | ( 1 << 2 ) ) ) )
	    {
	      if (n == string_end || c != ( wint_t ) * n )
		return  1 ;

	      new_no_leading_period =  1 ;
	      break;
	    }
	   
	default:
	normal_match:
	  if (n == string_end || c !=  ( ( flags & ( 1 << 4 ) ) ? ( ( __wc = ( ( wint_t ) * n ) ) > 255 ? __trwctype ( __wc , ( 01 ) ) : ( ( ( 1 + __ctype ) [ __wc ] & ( ( 01 ) ) ) ? ( 258 + __ctype ) [ __wc ] : ( __wc ) ) ) : ( ( wint_t ) * n ) ) )
	    return  1 ;
	}

      no_leading_period = new_no_leading_period;
      ++n;
    }

  if (n == string_end)
    return 0;

  if ((flags &  ( 1 << 3 ) ) && n != string_end && * n == L'/' )
     
    return 0;

  return  1 ;
}


static const  wchar_t *

 end_wpattern ( const wchar_t * pattern )
{
  const  wchar_t * p = pattern ;

  while (1)
    if (*++p ==  L'\0' )
       
      return pattern;
    else if (*p ==  L'[' )
      {
	 
	if (posixly_correct == 0)
	  posixly_correct = getenv ("POSIXLY_CORRECT") !=  0 ? 1 : - 1 ;

	 
	if (*++p ==  L'!' || ( posixly_correct < 0 && * p == L'^' ) )
	  ++p;
	 
	if (*p ==  L']' )
	  ++p;
	 
	while (*p !=  L']' )
	  if (*p++ ==  L'\0' )
	     
	    return pattern;
      }
    else if ((*p ==  L'?' || * p == L'*' || * p == L'+' || * p == L'@'
	      || *p ==  L'!' ) && p [ 1 ] == L'(' )
      p =  end_wpattern ( p + 1 ) ;
    else if (*p ==  L')' )
      break;

  return p + 1;
}


static int

 ext_wmatch ( wint_t opt , const wchar_t * pattern , const wchar_t * string , const wchar_t * string_end ,
      _Bool no_leading_period , int flags )
{
  const  wchar_t * startp ;
  size_t level;
  struct patternlist
  {
    struct patternlist *next;
     wchar_t str [ 1 ] ;
  } *list =  0 ;
  struct patternlist **lastp = &list;
  size_t pattern_len =  wcslen ( pattern ) ;
  const  wchar_t * p ;
  const  wchar_t * rs ;
  enum { ALLOCA_LIMIT = 8000 };

   
  level = 0;
  for (startp = p = pattern + 1; ; ++p)
    if (*p ==  L'\0' )
       
      return -1;
    else if (*p ==  L'[' )
      {
	 
	if (posixly_correct == 0)
	  posixly_correct = getenv ("POSIXLY_CORRECT") !=  0 ? 1 : - 1 ;

	 
	if (*++p ==  L'!' || ( posixly_correct < 0 && * p == L'^' ) )
	  ++p;
	 
	if (*p ==  L']' )
	  ++p;
	 
	while (*p !=  L']' )
	  if (*p++ ==  L'\0' )
	     
	    return -1;
      }
    else if ((*p ==  L'?' || * p == L'*' || * p == L'+' || * p == L'@'
	      || *p ==  L'!' ) && p [ 1 ] == L'(' )
       
      ++level;
    else if (*p ==  L')' )
      {
	if (level-- == 0)
	  {
	     
	     struct patternlist * newp ; size_t plen ; size_t plensize ; size_t newpsize ; plen = ( opt == L'?' || opt == L'@' ? pattern_len : p - startp + 1 ) ; plensize = plen * sizeof ( wchar_t ) ; newpsize = ( size_t ) ( & ( ( ( struct patternlist * ) 0 ) -> str ) ) + plensize ; if ( ( size_t ) - 1 / sizeof ( wchar_t ) < plen || newpsize < ( size_t ) ( & ( ( ( struct patternlist * ) 0 ) -> str ) ) || ALLOCA_LIMIT <= newpsize ) return - 1 ; newp = ( struct patternlist * ) alloca ( newpsize ) ; * ( ( wchar_t * ) ( wmemcpy ( newp -> str , startp , p - startp ) + ( p - startp ) ) ) = L'\0' ; newp -> next = 0 ; * lastp = newp ; lastp = & newp -> next ;
	    break;
	  }
      }
    else if (*p ==  L'|' )
      {
	if (level == 0)
	  {
	     struct patternlist * newp ; size_t plen ; size_t plensize ; size_t newpsize ; plen = ( opt == L'?' || opt == L'@' ? pattern_len : p - startp + 1 ) ; plensize = plen * sizeof ( wchar_t ) ; newpsize = ( size_t ) ( & ( ( ( struct patternlist * ) 0 ) -> str ) ) + plensize ; if ( ( size_t ) - 1 / sizeof ( wchar_t ) < plen || newpsize < ( size_t ) ( & ( ( ( struct patternlist * ) 0 ) -> str ) ) || ALLOCA_LIMIT <= newpsize ) return - 1 ; newp = ( struct patternlist * ) alloca ( newpsize ) ; * ( ( wchar_t * ) ( wmemcpy ( newp -> str , startp , p - startp ) + ( p - startp ) ) ) = L'\0' ; newp -> next = 0 ; * lastp = newp ; lastp = & newp -> next ;
	    startp = p + 1;
	  }
      }
   ( ( void ) ( ( list != 0 ) || ( __xassert ( "list != NULL" , __func__ , "./fnmatch_loop.c" , 1080 ) , 0 ) ) ) ;
   ( ( void ) ( ( p [ - 1 ] == L')' ) || ( __xassert ( "p[-1] == L(')')" , __func__ , "./fnmatch_loop.c" , 1081 ) , 0 ) ) ) ;

  switch (opt)
    {
    case  L'*' :
      if ( internal_fnwmatch ( p , string , string_end , no_leading_period , flags ) == 0 )
	return 0;
       

    case  L'+' :
      do
	{
	  for (rs = string; rs <= string_end; ++rs)
	     
	    if ( internal_fnwmatch ( list -> str , string , rs , no_leading_period ,
		     flags &  ( 1 << 0 ) ? flags : flags & ~ ( 1 << 2 ) ) == 0
		 
		&& ( internal_fnwmatch ( p , rs , string_end ,
			 rs == string
			 ? no_leading_period
			 : rs[-1] == '/' &&  ( ( flags & ( ( 1 << 0 ) | ( 1 << 2 ) ) ) == ( ( 1 << 0 ) | ( 1 << 2 ) ) ) ,
			 flags &  ( 1 << 0 )
			 ? flags : flags & ~ ( 1 << 2 ) ) == 0
		     
		    || (rs != string
			&&  internal_fnwmatch ( pattern - 1 , rs , string_end ,
				rs == string
				? no_leading_period
				: rs[-1] == '/' &&  ( ( flags & ( ( 1 << 0 ) | ( 1 << 2 ) ) ) == ( ( 1 << 0 ) | ( 1 << 2 ) ) ) ,
				flags &  ( 1 << 0 )
				? flags : flags & ~ ( 1 << 2 ) ) == 0 ) ) )
	       
	      return 0;
	}
      while ((list = list->next) !=  0 ) ;

       
      return  1 ;

    case  L'?' :
      if ( internal_fnwmatch ( p , string , string_end , no_leading_period , flags ) == 0 )
	return 0;
       

    case  L'@' :
      do
	 
	if ( internal_fnwmatch ( wcscat ( list -> str , p ) , string , string_end ,
		 no_leading_period,
		 flags &  ( 1 << 0 ) ? flags : flags & ~ ( 1 << 2 ) ) == 0 )
	   
	  return 0;
      while ((list = list->next) !=  0 ) ;

       
      return  1 ;

    case  L'!' :
      for (rs = string; rs <= string_end; ++rs)
	{
	  struct patternlist *runp;

	  for (runp = list; runp !=  0 ; runp = runp -> next )
	    if ( internal_fnwmatch ( runp -> str , string , rs ,  no_leading_period ,
		     flags &  ( 1 << 0 ) ? flags : flags & ~ ( 1 << 2 ) ) == 0 )
	      break;

	   
	  if (runp ==  0
	      && ( internal_fnwmatch ( p , rs , string_end ,
		       rs == string
		       ? no_leading_period
		       : rs[-1] == '/' &&  ( ( flags & ( ( 1 << 0 ) | ( 1 << 2 ) ) ) == ( ( 1 << 0 ) | ( 1 << 2 ) ) ) ,
		       flags &  ( 1 << 0 ) ? flags : flags & ~ ( 1 << 2 ) )
		  == 0))
	     
	    return 0;
	}

       
      return  1 ;

    default:
       ( ( void ) ( ( ! "Invalid extended matching operator" ) || ( __xassert ( "! \"Invalid extended matching operator\"" , __func__ , "./fnmatch_loop.c" , 1171 ) , 0 ) ) ) ;
      break;
    }

  return -1;
}




int
 gnu_fnmatch ( const char * pattern , const char * string , int flags )
{
  if ( ( ( ( int ) __ctype [ 520 ] ) ) != 1 )
    {
      mbstate_t ps;
      size_t patsize;
      size_t strsize;
      size_t totsize;
      wchar_t *wpattern;
      wchar_t *wstring;
      int res;

       
      memset (&ps, '\0', sizeof (ps));
      patsize = mbsrtowcs ( 0 , & pattern , 0 , & ps ) + 1 ;
      if ( ( patsize == 0 ) )
	 
	return -1;
       ( ( void ) ( ( mbsinit ( & ps ) ) || ( __xassert ( "mbsinit (&ps)" , __func__ , "fnmatch.c" , 327 ) , 0 ) ) ) ;
      strsize = mbsrtowcs ( 0 , & string , 0 , & ps ) + 1 ;
      if ( ( strsize == 0 ) )
	 
	return -1;
       ( ( void ) ( ( mbsinit ( & ps ) ) || ( __xassert ( "mbsinit (&ps)" , __func__ , "fnmatch.c" , 334 ) , 0 ) ) ) ;
      totsize = patsize + strsize;
      if ( ( ! ( patsize <= totsize && totsize <= ( ( size_t ) - 1 ) / sizeof ( wchar_t ) ) ) )
	{
	  errno =  12 ;
	  return -1;
	}

       
      if ( ( totsize < 2000 ) )
	wpattern = (wchar_t *) alloca (totsize * sizeof (wchar_t));
      else
	{
	  wpattern = malloc (totsize * sizeof (wchar_t));
	  if ( ( ! wpattern ) )
	    {
	      errno =  12 ;
	      return -1;
	    }
	}
      wstring = wpattern + patsize;

       
      mbsrtowcs (wpattern, &pattern, patsize, &ps);
       ( ( void ) ( ( mbsinit ( & ps ) ) || ( __xassert ( "mbsinit (&ps)" , __func__ , "fnmatch.c" , 360 ) , 0 ) ) ) ;
      mbsrtowcs (wstring, &string, strsize, &ps);

      res = internal_fnwmatch (wpattern, wstring, wstring + strsize - 1,
			       flags &  ( 1 << 2 ) , flags ) ;

      if ( ( ! ( totsize < 2000 ) ) )
	free (wpattern);
      return res;
    }

  return internal_fnmatch (pattern, string, string + strlen (string),
			   flags &  ( 1 << 2 ) , flags ) ;
}


#ident "acomp: (CCS) 4.2  07/24/05 (osr600mp1.bl2l)"