// glob.c

 /*

  * Copyright (c) 1989, 1993

  *	The Regents of the University of California.  All rights reserved.

  *

  * This code is derived from software contributed to Berkeley by

  * Guido van Rossum.

  *

  * 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.

  * 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.

  */

 /* Portions Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).All rights reserved.  */

 #if defined(LIBC_SCCS) && !defined(lint)

 static char sccsid[] = "@(#)glob.c	8.3 (Berkeley) 10/13/93";

 #endif /* LIBC_SCCS and not lint */

 #include <sys/cdefs.h>

 __FBSDID("$FreeBSD: src/lib/libc/gen/glob.c,v 1.23 2005/09/14 19:14:32 ache Exp $");

 /*

  * glob(3) -- a superset of the one defined in POSIX 1003.2.

  *

  * The [!...] convention to negate a range is supported (SysV, Posix, ksh).

  *

  * Optional extra services, controlled by flags not defined by POSIX:

  *

  * GLOB_QUOTE:

  *	Escaping convention: \ inhibits any special meaning the following

  *	character might have (except \ at end of string is retained).

  * GLOB_MAGCHAR:

  *	Set in gl_flags if pattern contained a globbing character.

  * GLOB_NOMAGIC:

  *	Same as GLOB_NOCHECK, but it will only append pattern if it did

  *	not contain any magic characters.  [Used in csh style globbing]

  * GLOB_ALTDIRFUNC:

  *	Use alternately specified directory access functions.

  * GLOB_TILDE:

  *	expand ~user/foo to the /home/dir/of/user/foo

  * GLOB_BRACE:

  *	expand {1,2}{a,b} to 1a 1b 2a 2b

  * gl_matchc:

  *	Number of matches in the current invocation of glob.

  */

 /*

  * Some notes on multibyte character support:

  * 1. Patterns with illegal byte sequences match nothing - even if

  *    GLOB_NOCHECK is specified.

  * 2. Illegal byte sequences in filenames are handled by treating them as

  *    single-byte characters with a value of the first byte of the sequence

  *    cast to wchar_t.

  * 3. State-dependent encodings are not currently supported.

  */

 #include <sys/param.h>

 #include <sys/stat.h>

 #include <ctype.h>

 #include <dirent.h>

 #include <errno.h>

 #include <glob.h>

 #include <limits.h>

 #include <pwd.h>

 #include <stdint.h>

 #include <stdio.h>

 #include <stdlib.h>

 #include <string.h>

 #include <unistd.h>

 #include <wchar.h>

 #include "libc_collate.h"

 #if (defined(__SYMBIAN32__) && (defined(__WINSCW__) || defined(__WINS__)))

 #include "libc_wsd_defs.h"

 #include "reent.h"

 #endif	//defined(__SYMBIAN32__) && (defined(__WINSCW__) || defined(__WINS__))

 #ifdef __cplusplus

 extern "C" {

 #endif

 #ifdef __SYMBIAN32__

 extern char LC_COLLATE_LocaleName[30];

 #ifdef EMULATOR

 char *GET_WSD_VAR_NAME(LC_COLLATE_LocaleName, g)();

 #define LC_COLLATE_LocaleName (GET_WSD_VAR_NAME(LC_COLLATE_LocaleName, g)())

 #endif 	//EMULATOR

 //Declared and defined from libc_collate.h and vfscanf.c

 extern int __collate_range_cmp(int , int );

 #endif	//__SYMBIAN32__

 #define	DOLLAR		'$'

 #define	DOT			'.'

 #define	EOS			'\0'

 #define	LBRACKET	'['

 #define	NOT			'!'

 #define	QUESTION	'?'

 #define	QUOTE		'\\'

 #define	RANGE		'-'

 #define	RBRACKET	']'

 // For Symbian Environment the path is specified using the '\'

 // unlike in the Linux where the path seprator '/' is used.

 // Since '\\' as path seprator is used the escaping flag 

 // 'QUOTE' cannot be used here.

 // For e.g. ..\\test\\hollows\\*

 #ifdef __SYMBIAN32__

 	#define	SEP		'\\'

 #else

 	#define SEP		'/'

 #endif //__SYMBIAN32__

 #define	STAR		'*'

 #define	TILDE		'~'

 #define	UNDERSCORE	'_'

 #define	LBRACE		'{'

 #define	RBRACE		'}'

 #define	SLASH		'/'

 #define	COMMA		','

 #ifndef __SYMBIAN32__

 #ifndef DEBUG

 #define	M_QUOTE		0x8000000000ULL

 #define	M_PROTECT	0x4000000000ULL

 #define	M_MASK		0xffffffffffULL

 #define	M_CHAR		0x00ffffffffULL

 typedef uint_fast64_t Char;

 #else		//DEBUG

 #define	M_QUOTE		0x80

 #define	M_PROTECT	0x40

 #define	M_MASK		0xff

 #define	M_CHAR		0x7f

 typedef char Char;

 #endif 		//DEBUG

 #else    	//__SYMBIAN32__

 #define	M_QUOTE		0x80

 #define	M_PROTECT	0x40

 #define	M_MASK		0xff

 #define	M_CHAR		0x7f

 typedef unsigned char Char;

 #endif		//__SYMBIAN32__

 #define	CHAR(c)		((Char)((c)&M_CHAR))

 #define	META(c)		((Char)((c)|M_QUOTE))

 #define	M_ALL		META('*')

 #define	M_END		META(']')

 #define	M_NOT		META('!')

 #define	M_ONE		META('?')

 #define	M_RNG		META('-')

 #define	M_SET		META('[')

 #define	ismeta(c)	(((c)&M_QUOTE) != 0)

 static int	 compare(const void *, const void *);

 static int	 g_Ctoc(const Char *, char *, u_int);

 static int	 g_lstat(Char *, struct stat *, glob_t *);

 static DIR	*g_opendir(Char *, glob_t *);

 static Char	*g_strchr(Char *, wchar_t);

 #ifdef notdef

 static Char	*g_strcat(Char *, const Char *);

 #endif

 static int	 g_stat(Char *, struct stat *, glob_t *);

 static int	 glob0(const Char *, glob_t *, int *);

 static int	 glob1(Char *, glob_t *, int *);

 static int	 glob2(Char *, Char *, Char *, Char *, glob_t *, int *);

 static int	 glob3(Char *, Char *, Char *, Char *, Char *, glob_t *, int *);

 static int	 globextend(const Char *, glob_t *, int *);

 static const Char *	

 		 globtilde(const Char *, Char *, size_t, glob_t *);

 static int	 globexp1(const Char *, glob_t *, int *);

 static int	 globexp2(const Char *, const Char *, glob_t *, int *, int *);

 static int	 match(Char *, Char *, Char *);

 #ifdef DEBUG

 static void	 qprintf(const char *, Char *);

 #endif

 // EXTERNAL FUNCTION PROTOTYPES

 //--------------------------------------------------------------------------------------------

 //Function Name : int glob(glob(const char *, int flags, int (*)(const char *, int), glob_t *)

 //Description   : It takes pattern to be searched, flags and the structure of the type glob_t.

 //				  It can optionally also take  If errfunc is not NULL, it will be called in 

 //				  error with the arguments epath,  a  pointer  to  the case of an path which 

 //			      failed

 //				  

 //Return Value  : If successful returns the pathnames of the searched pattern contained 

 //				  in the glob_t structure member reference pointer gl_pathv. In case

 //				  failure, gl_pathv is NULL.

 //----------------------------------------------------------------------------------------------

 EXPORT_C int

 glob(pattern, flags, errfunc, pglob)

 	const char *pattern;

 	int flags, (*errfunc)(const char *, int);

 	glob_t *pglob;

 {

 	const u_char *patnext;

 	int limit;

 	Char *bufnext, *bufend, patbuf[MAXPATHLEN], prot;

 	mbstate_t mbs;

 	wchar_t wc;

 	size_t clen;

 	patnext = (u_char *) pattern;

 	// Since we are using '\\' as path seprator, this flag needs to be mentioned

 	// by default in Symbian. Instead this can be hardcoded here.

 	#ifdef __SYMBIAN32__

 		flags = flags | GLOB_NOESCAPE;

 	#endif

 	if (!(flags & GLOB_APPEND)) {

 		pglob->gl_pathc = 0;

 		pglob->gl_pathv = NULL;

 		if (!(flags & GLOB_DOOFFS))

 			pglob->gl_offs = 0;

 	}

 	if (flags & GLOB_LIMIT) {

 		limit = pglob->gl_matchc;

 		if (limit == 0)

 			limit = ARG_MAX;

 	} else

 		limit = 0;

 	pglob->gl_flags = flags & ~GLOB_MAGCHAR;

 	pglob->gl_errfunc = errfunc;

 	pglob->gl_matchc = 0;

 	bufnext = patbuf;

 	bufend = bufnext + MAXPATHLEN - 1;

 	if (flags & GLOB_NOESCAPE) {

 		memset(&mbs, 0, sizeof(mbs));

 		while (bufend - bufnext >= MB_CUR_MAX) {

 			clen = mbrtowc(&wc,(char*)patnext, MB_LEN_MAX, &mbs);

 			if (clen == (size_t)-1 || clen == (size_t)-2)

 				return (GLOB_NOMATCH);

 			else if (clen == 0)

 				break;

 			*bufnext++ = wc;

 			patnext += clen;

 		}

 	} else {

 		/* Protect the quoted characters. */

 		memset(&mbs, 0, sizeof(mbs));

 		while (bufend - bufnext >= MB_CUR_MAX) {

 			if (*patnext == QUOTE) {

 				if (*++patnext == EOS) {

 					*bufnext++ = QUOTE | M_PROTECT;

 					continue;

 				}

 				prot = M_PROTECT;

 			} else

 				prot = 0;

 			clen = mbrtowc(&wc, (char*)patnext, MB_LEN_MAX, &mbs);

 			if (clen == (size_t)-1 || clen == (size_t)-2)

 				return (GLOB_NOMATCH);

 			else if (clen == 0)

 				break;

 			*bufnext++ = wc | prot;

 			patnext += clen;

 		}

 	}

 	*bufnext = EOS;

 	if (flags & GLOB_BRACE)

 	    return globexp1(patbuf, pglob, &limit);

 	else

 	    return glob0(patbuf, pglob, &limit);

 }

 /*

  * Expand recursively a glob {} pattern. When there is no more expansion

  * invoke the standard globbing routine to glob the rest of the magic

  * characters

  */

 static int

 globexp1(pattern, pglob, limit)

 	const Char *pattern;

 	glob_t *pglob;

 	int *limit;

 {

 	const Char* ptr = pattern;

 	int rv;

 	/* Protect a single {}, for find(1), like csh */

 	if (pattern[0] == LBRACE && pattern[1] == RBRACE && pattern[2] == EOS)

 		return glob0(pattern, pglob, limit);

 	while ((ptr = (const Char *) g_strchr((Char *) ptr, LBRACE)) != NULL)

 		if (!globexp2(ptr, pattern, pglob, &rv, limit))

 			return rv;

 	return glob0(pattern, pglob, limit);

 }

 /*

  * Recursive brace globbing helper. Tries to expand a single brace.

  * If it succeeds then it invokes globexp1 with the new pattern.

  * If it fails then it tries to glob the rest of the pattern and returns.

  */

 static int

 globexp2(ptr, pattern, pglob, rv, limit)

 	const Char *ptr, *pattern;

 	glob_t *pglob;

 	int *rv, *limit;

 {

 	int     i;

 	Char   *lm, *ls;

 	const Char *pe, *pm, *pm1, *pl;

 	Char    patbuf[MAXPATHLEN];

 	/* copy part up to the brace */

 	for (lm = patbuf, pm = pattern; pm != ptr; *lm++ = *pm++)

 		continue;

 	*lm = EOS;

 	ls = lm;

 	/* Find the balanced brace */

 	for (i = 0, pe = ++ptr; *pe; pe++)

 		if (*pe == LBRACKET) {

 			/* Ignore everything between [] */

 			for (pm = pe++; *pe != RBRACKET && *pe != EOS; pe++)

 				continue;

 			if (*pe == EOS) {

 				/*

 				 * We could not find a matching RBRACKET.

 				 * Ignore and just look for RBRACE

 				 */

 				pe = pm;

 			}

 		}

 		else if (*pe == LBRACE)

 			i++;

 		else if (*pe == RBRACE) {

 			if (i == 0)

 				break;

 			i--;

 		}

 	/* Non matching braces; just glob the pattern */

 	if (i != 0 || *pe == EOS) {

 		*rv = glob0(patbuf, pglob, limit);

 		return 0;

 	}

 	for (i = 0, pl = pm = ptr; pm <= pe; pm++)

 		switch (*pm) {

 		case LBRACKET:

 			/* Ignore everything between [] */

 			for (pm1 = pm++; *pm != RBRACKET && *pm != EOS; pm++)

 				continue;

 			if (*pm == EOS) {

 				/*

 				 * We could not find a matching RBRACKET.

 				 * Ignore and just look for RBRACE

 				 */

 				pm = pm1;

 			}

 			break;

 		case LBRACE:

 			i++;

 			break;

 		case RBRACE:

 			if (i) {

 			    i--;

 			    break;

 			}

 			/* FALLTHROUGH */

 		case COMMA:

 			if (i && *pm == COMMA)

 				break;

 			else {

 				/* Append the current string */

 				for (lm = ls; (pl < pm); *lm++ = *pl++)

 					continue;

 				/*

 				 * Append the rest of the pattern after the

 				 * closing brace

 				 */

 				for (pl = pe + 1; (*lm++ = *pl++) != EOS;)

 					continue;

 				/* Expand the current pattern */

 #ifdef DEBUG

 				qprintf("globexp2:", patbuf);

 #endif

 				*rv = globexp1(patbuf, pglob, limit);

 				/* move after the comma, to the next string */

 				pl = pm + 1;

 			}

 			break;

 		default:

 			break;

 		}

 	*rv = 0;

 	return 0;

 }

 /*

  * expand tilde from the passwd file.

  */

 static const Char *

 globtilde(pattern, patbuf, patbuf_len, pglob)

 	const Char *pattern;

 	Char *patbuf;

 	size_t patbuf_len;

 	glob_t *pglob;

 {

 #ifndef  __SYMBIAN32__

 	struct passwd *pwd;

 #endif

 	char *h;

 	const Char *p;

 	Char *b, *eb;

 	if (*pattern != TILDE || !(pglob->gl_flags & GLOB_TILDE))

 		return pattern;

 	/* 

 	 * Copy up to the end of the string or / 

 	 */

 	eb = &patbuf[patbuf_len - 1];

 #ifdef __SYMBIAN32__

 	for (p = pattern + 1, h = (char *) patbuf;

 	    h < (char *)eb && *p && *p != SEP ; *h++ = *p++)

 		continue;

 	*h = EOS;

 	if (((char *) patbuf)[0] == EOS) {

 		/*

 		 * handle a plain ~ or ~\\ by getting the

 		 * secure Id for this process. It shall 

 		 * return the path as C:\\private\\<secureId>

 		 * on emulator and Z:\\private\\<secureId>

 		 * on hardware

 		 */

 	    if( NULL == getcwd(h, patbuf_len) )

 			return pattern;

 	}

 	else{

 		/*

 		 * Its ~<path>\\.. This will not be handled. Returns the

 		 * pattern as it is. 

 		 */

 		return pattern;

 	}

 #  else

 	for (p = pattern + 1, h = (char *) patbuf;

 	    h < (char *)eb && *p && *p != SLASH; *h++ = *p++)

 		continue;

 	*h = EOS;

 	if (((char *) patbuf)[0] == EOS) {

 		/*

 		 * handle a plain ~ or ~/ by expanding $HOME first (iff

 		 * we're not running setuid or setgid) and then trying

 		 * the password file

 		 */

 		if (issetugid() != 0 ||

 		    (h = getenv("HOME")) == NULL) {

 			if (((h = getlogin()) != NULL &&

 			     (pwd = getpwnam(h)) != NULL) ||

 			    (pwd = getpwuid(getuid())) != NULL)

 				h = pwd->pw_dir;

 			else

 				return pattern;

 		}

 	}

 	else {

 		/*

 		 * Expand a ~user

 		 */

 		if ((pwd = getpwnam((char*) patbuf)) == NULL)

 			return pattern;

 		else

 			h = pwd->pw_dir;

 	}

 #endif //__SYMBIAN32__

 	/* Copy the home directory */

 	for (b = patbuf; b < eb && *h; *b++ = *h++)

 		continue;

 	/* Append the rest of the pattern */

 	while (b < eb && (*b++ = *p++) != EOS)

 		continue;

 	*b = EOS;

 	return patbuf;

 }

 /*

  * The main glob() routine: compiles the pattern (optionally processing

  * quotes), calls glob1() to do the real pattern matching, and finally

  * sorts the list (unless unsorted operation is requested).  Returns 0

  * if things went well, nonzero if errors occurred.

  */

 static int

 glob0(pattern, pglob, limit)

 	const Char *pattern;

 	glob_t *pglob;

 	int *limit;

 {

 	const Char *qpatnext;

 	int c, err, oldpathc;

 	Char *bufnext, patbuf[MAXPATHLEN];

 	qpatnext = globtilde(pattern, patbuf, MAXPATHLEN, pglob);

 	oldpathc = pglob->gl_pathc;

 	bufnext = patbuf;

 	/* We don't need to check for buffer overflow any more. */

 	while ((c = *qpatnext++) != EOS) {

 		switch (c) {

 		case LBRACKET:

 			c = *qpatnext;

 			if (c == NOT)

 				++qpatnext;

 			if (*qpatnext == EOS ||

 			    g_strchr((Char *) qpatnext+1, RBRACKET) == NULL) {

 				*bufnext++ = LBRACKET;

 				if (c == NOT)

 					--qpatnext;

 				break;

 			}

 			*bufnext++ = M_SET;

 			if (c == NOT)

 				*bufnext++ = M_NOT;

 			c = *qpatnext++;

 			do {

 				*bufnext++ = CHAR(c);

 				if (*qpatnext == RANGE &&

 				    (c = qpatnext[1]) != RBRACKET) {

 					*bufnext++ = M_RNG;

 					*bufnext++ = CHAR(c);

 					qpatnext += 2;

 				}

 			} while ((c = *qpatnext++) != RBRACKET);

 			pglob->gl_flags |= GLOB_MAGCHAR;

 			*bufnext++ = M_END;

 			break;

 		case QUESTION:

 			pglob->gl_flags |= GLOB_MAGCHAR;

 			*bufnext++ = M_ONE;

 			break;

 		case STAR:

 			pglob->gl_flags |= GLOB_MAGCHAR;

 			/* collapse adjacent stars to one,

 			 * to avoid exponential behavior

 			 */

 			if (bufnext == patbuf || bufnext[-1] != M_ALL)

 			    *bufnext++ = M_ALL;

 			break;

 		default:

 			*bufnext++ = CHAR(c);

 			break;

 		}

 	}

 	*bufnext = EOS;

 #ifdef DEBUG

 	qprintf("glob0:", patbuf);

 #endif

 	if ((err = glob1(patbuf, pglob, limit)) != 0)

 		return(err);

 	/*

 	 * If there was no match we are going to append the pattern

 	 * if GLOB_NOCHECK was specified or if GLOB_NOMAGIC was specified

 	 * and the pattern did not contain any magic characters

 	 * GLOB_NOMAGIC is there just for compatibility with csh.

 	 */

 	if (pglob->gl_pathc == oldpathc) {

 		if (((pglob->gl_flags & GLOB_NOCHECK) ||

 		    ((pglob->gl_flags & GLOB_NOMAGIC) &&

 			!(pglob->gl_flags & GLOB_MAGCHAR))))

 			return(globextend(pattern, pglob, limit));

 		else

 			return(GLOB_NOMATCH);

 	}

 	if (!(pglob->gl_flags & GLOB_NOSORT))

 		qsort(pglob->gl_pathv + pglob->gl_offs + oldpathc,

 		    pglob->gl_pathc - oldpathc, sizeof(char *), compare);

 	return(0);

 }

 static int

 compare(p, q)

 	const void *p, *q;

 {

 	return(strcmp(*(char **)p, *(char **)q));

 }

 static int

 glob1(pattern, pglob, limit)

 	Char *pattern;

 	glob_t *pglob;

 	int *limit;

 {

 	Char pathbuf[MAXPATHLEN];

 	/* A null pathname is invalid -- POSIX 1003.1 sect. 2.4. */

 	if (*pattern == EOS)

 		return(0);

 	return(glob2(pathbuf, pathbuf, pathbuf + MAXPATHLEN - 1,

 	    pattern, pglob, limit));

 }

 /*

  * The functions glob2 and glob3 are mutually recursive; there is one level

  * of recursion for each segment in the pattern that contains one or more

  * meta characters.

  */

 static int

 glob2(pathbuf, pathend, pathend_last, pattern, pglob, limit)

 	Char *pathbuf, *pathend, *pathend_last, *pattern;

 	glob_t *pglob;

 	int *limit;

 {

 	struct stat sb;

 	Char *p, *q;

 	int anymeta;

 	/*

 	 * Loop over pattern segments until end of pattern or until

 	 * segment with meta character found.

 	 */

 	for (anymeta = 0;;) {

 		if (*pattern == EOS) {		/* End of pattern? */

 			*pathend = EOS;

 			if (g_lstat(pathbuf, &sb, pglob))

 				return(0);

 			if (((pglob->gl_flags & GLOB_MARK) &&

 			    pathend[-1] != SEP) && (S_ISDIR(sb.st_mode)

 			    || (S_ISLNK(sb.st_mode) &&

 			    (g_stat(pathbuf, &sb, pglob) == 0) &&

 			    S_ISDIR(sb.st_mode)))) {

 				if (pathend + 1 > pathend_last)

 					return (GLOB_ABORTED);

 				*pathend++ = SEP;

 				*pathend = EOS;

 			}

 			++pglob->gl_matchc;

 			return(globextend(pathbuf, pglob, limit));

 		}

 		/* Find end of next segment, copy tentatively to pathend. */

 		q = pathend;

 		p = pattern;

 		while (*p != EOS && *p != SEP) {

 			if (ismeta(*p))

 				anymeta = 1;

 			if (q + 1 > pathend_last)

 				return (GLOB_ABORTED);

 			*q++ = *p++;

 		}

 		if (!anymeta) {		/* No expansion, do next segment. */

 			pathend = q;

 			pattern = p;

 			while (*pattern == SEP) {

 				if (pathend + 1 > pathend_last)

 					return (GLOB_ABORTED);

 				*pathend++ = *pattern++;

 			}

 		} else			/* Need expansion, recurse. */

 			return(glob3(pathbuf, pathend, pathend_last, pattern, p,

 			    pglob, limit));

 	}

 	/* NOTREACHED */

 }

 static int

 glob3(pathbuf, pathend, pathend_last, pattern, restpattern, pglob, limit)

 	Char *pathbuf, *pathend, *pathend_last, *pattern, *restpattern;

 	glob_t *pglob;

 	int *limit;

 {

 	struct dirent *dp;

 	DIR *dirp;

 	int err;

 	char buf[MAXPATHLEN];

 	/*

 	 * The readdirfunc declaration can't be prototyped, because it is

 	 * assigned, below, to two functions which are prototyped in glob.h

 	 * and dirent.h as taking pointers to differently typed opaque

 	 * structures.

 	 */

 	struct dirent *(*readdirfunc)();

 	if (pathend > pathend_last)

 		return (GLOB_ABORTED);

 	*pathend = EOS;

 	errno = 0;

 	if ((dirp = g_opendir(pathbuf, pglob)) == NULL) {

 		/* TODO: don't call for ENOENT or ENOTDIR? */

 		if (pglob->gl_errfunc) {

 			if (g_Ctoc(pathbuf, buf, sizeof(buf)))

 				return (GLOB_ABORTED);

 			if (pglob->gl_errfunc(buf, errno) ||

 			    pglob->gl_flags & GLOB_ERR)

 				return (GLOB_ABORTED);

 		}

 		return(0);

 	}

 	err = 0;

 	/* Search directory for matching names. */

 	if (pglob->gl_flags & GLOB_ALTDIRFUNC)

 		readdirfunc = pglob->gl_readdir;

 	else

 		readdirfunc = readdir;

 		while (NULL != (dp = (*readdirfunc)(dirp))) {

 		u_char *sc;

 		Char *dc;

 		wchar_t wc;

 		size_t clen;

 		mbstate_t mbs;

 		/* Initial DOT must be matched literally. */

 		if (dp->d_name[0] == DOT && *pattern != DOT)

 			continue;

 		memset(&mbs, 0, sizeof(mbs));

 		dc = pathend;

 		sc = (u_char *) dp->d_name;

 		while (dc < pathend_last) {

 			clen = mbrtowc(&wc,(char*)sc, MB_LEN_MAX, &mbs);

 			if (clen == (size_t)-1 || clen == (size_t)-2) {

 				wc = *sc;

 				clen = 1;

 				memset(&mbs, 0, sizeof(mbs));

 			}

 			if ((*dc++ = wc) == EOS)

 				break;

 			sc += clen;

 		}

 		if (!match(pathend, pattern, restpattern)) {

 			*pathend = EOS;

 			continue;

 		}

 		err = glob2(pathbuf, --dc, pathend_last, restpattern,

 		    pglob, limit);

 		if (err)

 			break;

 	}

 	if (pglob->gl_flags & GLOB_ALTDIRFUNC)

 		(*pglob->gl_closedir)(dirp);

 	else

 		closedir(dirp);

 	return(err);

 }

 /*

  * Extend the gl_pathv member of a glob_t structure to accomodate a new item,

  * add the new item, and update gl_pathc.

  *

  * This assumes the BSD realloc, which only copies the block when its size

  * crosses a power-of-two boundary; for v7 realloc, this would cause quadratic

  * behavior.

  *

  * Return 0 if new item added, error code if memory couldn't be allocated.

  *

  * Invariant of the glob_t structure:

  *	Either gl_pathc is zero and gl_pathv is NULL; or gl_pathc > 0 and

  *	gl_pathv points to (gl_offs + gl_pathc + 1) items.

  */

 static int

 globextend(path, pglob, limit)

 	const Char *path;

 	glob_t *pglob;

 	int *limit;

 {

 	char **pathv;

 	int i;

 	u_int newsize, len;

 	char *copy;

 	const Char *p;

 	if (*limit && pglob->gl_pathc > *limit) {

 		errno = 0;

 		return (GLOB_NOSPACE);

 	}

 	newsize = sizeof(*pathv) * (2 + pglob->gl_pathc + pglob->gl_offs);

 	pathv = pglob->gl_pathv ?

 		    realloc((char *)pglob->gl_pathv, newsize) :

 		    malloc(newsize);

 	if (pathv == NULL) {

 		if (pglob->gl_pathv) {

 			free(pglob->gl_pathv);

 			pglob->gl_pathv = NULL;

 		}

 		return(GLOB_NOSPACE);

 	}

 	if (pglob->gl_pathv == NULL && pglob->gl_offs > 0) {

 		/* first time around -- clear initial gl_offs items */

 		pathv += pglob->gl_offs;

 		for (i = pglob->gl_offs; --i >= 0; )

 			*--pathv = NULL;

 	}

 	pglob->gl_pathv = pathv;

 	for (p = path; *p++;)

 		continue;

 	len = MB_CUR_MAX * (size_t)(p - path);	/* XXX overallocation */

 	if ((copy = malloc(len)) != NULL) {

 		if (g_Ctoc(path, copy, len)) {

 			free(copy);

 			return (GLOB_NOSPACE);

 		}

 		pathv[pglob->gl_offs + pglob->gl_pathc++] = copy;

 	}

 	pathv[pglob->gl_offs + pglob->gl_pathc] = NULL;

 	return(copy == NULL ? GLOB_NOSPACE : 0);

 }

 /*

  * pattern matching function for filenames.  Each occurrence of the *

  * pattern causes a recursion level.

  */

 static int

 match(name, pat, patend)

 	Char *name, *pat, *patend;

 {

 	int ok, negate_range;

 	Char c, k;

 	while (pat < patend) {

 		c = *pat++;

 		switch (c & M_MASK) {

 		case M_ALL:

 			if (pat == patend)

 				return(1);

 			do

 			    if (match(name, pat, patend))

 				    return(1);

 			while (*name++ != EOS);

 			return(0);

 		case M_ONE:

 			if (*name++ == EOS)

 				return(0);

 			break;

 		case M_SET:

 			ok = 0;

 			if ((k = *name++) == EOS)

 				return(0);

 			if ((negate_range = ((*pat & M_MASK) == M_NOT)) != EOS)

 				++pat;

 			while (((c = *pat++) & M_MASK) != M_END)

 				if ((*pat & M_MASK) == M_RNG) {

 					if (

 					// As used in vfscanf.c 

 					#ifndef __SYMBIAN32__		

 						__collate_load_error ?

 					#else

 						((strcmp("C",(const char*) LC_COLLATE_LocaleName)==0) ||(strcmp("POSIX", (const char*) LC_COLLATE_LocaleName)==0 )) ?

 					#endif	

 					    CHAR(c) <= CHAR(k) && CHAR(k) <= CHAR(pat[1]) :

 					       __collate_range_cmp(CHAR(c), CHAR(k)) <= 0

 					    && __collate_range_cmp(CHAR(k), CHAR(pat[1])) <= 0

 					   )

 						ok = 1;

 					pat += 2;

 				} else if (c == k)

 					ok = 1;

 			if (ok == negate_range)

 				return(0);

 			break;

 		default:

 			if (*name++ != c)

 				return(0);

 			break;

 		}

 	}

 	return(*name == EOS);

 }

 // EXTERNAL FUNCTION PROTOTYPES

 //-----------------------------------------------------------------------------

 //Function Name : void globfree(struct glob_t*)

 //

 //Description   : Free allocated data belonging to a glob_t structure. Memory 

 //				  which was dynamically allocated storage from an earlier call to glob()

 //				 

 //Return Value  : None

 //				  

 //-----------------------------------------------------------------------------

 EXPORT_C void

 globfree(pglob)

 	glob_t *pglob;

 {

 	int i;

 	char **pp;

 	if (pglob->gl_pathv != NULL) {

 		pp = pglob->gl_pathv + pglob->gl_offs;

 		for (i = pglob->gl_pathc; i--; ++pp)

 			if (*pp)

 				free(*pp);

 		free(pglob->gl_pathv);

 		pglob->gl_pathv = NULL;

 	}

 }

 static DIR *

 g_opendir(str, pglob)

 	Char *str;

 	glob_t *pglob;

 {

 	char buf[MAXPATHLEN];

 	if (!*str)

 		strcpy(buf, ".");

 	else {

 		if (g_Ctoc(str, buf, sizeof(buf)))

 			return (NULL);

 	}

 	if (pglob->gl_flags & GLOB_ALTDIRFUNC)

 		return((*pglob->gl_opendir)(buf));

 	return(opendir(buf));

 }

 static int

 g_lstat(fn, sb, pglob)

 	Char *fn;

 	struct stat *sb;

 	glob_t *pglob;

 {

 	char buf[MAXPATHLEN];

 	if (g_Ctoc(fn, buf, sizeof(buf))) {

 		errno = ENAMETOOLONG;

 		return (-1);

 	}

 	if (pglob->gl_flags & GLOB_ALTDIRFUNC)

 		return((*pglob->gl_lstat)(buf, sb));

 	return(lstat(buf, sb));

 }

 static int

 g_stat(fn, sb, pglob)

 	Char *fn;

 	struct stat *sb;

 	glob_t *pglob;

 {

 	char buf[MAXPATHLEN];

 	if (g_Ctoc(fn, buf, sizeof(buf))) {

 		errno = ENAMETOOLONG;

 		return (-1);

 	}

 	if (pglob->gl_flags & GLOB_ALTDIRFUNC)

 		return((*pglob->gl_stat)(buf, sb));

 	return(stat(buf, sb));

 }

 static Char *

 g_strchr(Char *str, wchar_t ch)

 {

 	do {

 		if (*str == ch)

 			return (str);

 	} while (*str++);

 	return (NULL);

 }

 static int

 g_Ctoc(str, buf, len)

 	const Char *str;

 	char *buf;

 	u_int len;

 {

 	mbstate_t mbs;

 	size_t clen;

 	memset(&mbs, 0, sizeof(mbs));

 	while (len >= MB_CUR_MAX) {

 		clen = wcrtomb(buf, *str, &mbs);

 		if (clen == (size_t)-1)

 			return (1);

 		if (*str == L'\0')

 			return (0);

 		str++;

 		buf += clen;

 		len -= clen;

 	}

 	return (1);

 }

 #ifdef DEBUG

 static void

 qprintf(str, s)

 	const char *str;

 	Char *s;

 {

 	Char *p;

 	(void)printf("%s:\n", str);

 	for (p = s; *p; p++)

 		(void)printf("%c", CHAR(*p));

 	(void)printf("\n");

 	for (p = s; *p; p++)

 		(void)printf("%c", *p & M_PROTECT ? '"' : ' ');

 	(void)printf("\n");

 	for (p = s; *p; p++)

 		(void)printf("%c", ismeta(*p) ? '_' : ' ');

 	(void)printf("\n");

 }

 #endif

 #ifdef __cplusplus

 } // extern "C"

 #endif