hawk/lib/gem-glob.c

/*
    Copyright (c) 2006-2020 Chung, Hyung-Hwan. All rights reserved.

    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.

    THIS SOFTWARE IS PROVIDED BY THE AUTHOR "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 AUTHOR 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.
 */

/*
 * Do NOT edit glob.c. Edit glob.c.m4 instead.
 *
 * Generate gem-glob.c with m4
 *   $ m4 gem-glob.c.m4 > gem-glob.c
 */

#include "hawk-prv.h"
#include <hawk-chr.h>
#include <hawk-ecs.h>
#include <hawk-dir.h>
#include <hawk-glob.h>

#include "syscall.h"

#define NO_RECURSION 1

enum segment_type_t
{
        NONE,
        ROOT,
        NORMAL
};
typedef enum segment_type_t segment_type_t;


#define IS_ESC(c) HAWK_FNMAT_IS_ESC(c)
#define IS_SEP(c) HAWK_FNMAT_IS_SEP(c)
#define IS_NIL(c) ((c) == '\0')
#define IS_SEP_OR_NIL(c) (IS_SEP(c) || IS_NIL(c))

/* this macro only checks for top-level wild-cards among these.
 *  *, ?, [], !, -
 * see str-fnmat.c for more wild-card letters
 */
#define IS_WILD(c) ((c) == '*' || (c) == '?' || (c) == '[')


static hawk_bch_t* wcs_to_mbuf (hawk_gem_t* g, const hawk_uch_t* wcs, hawk_becs_t* mbuf)
{
	hawk_oow_t ml, wl;

	if (hawk_gem_convutobcstr(g, wcs, &wl, HAWK_NULL, &ml) <= -1 ||
	    hawk_becs_setlen(mbuf, ml) == (hawk_oow_t)-1) return HAWK_NULL;

	hawk_gem_convutobcstr (g, wcs, &wl, HAWK_BECS_PTR(mbuf), &ml);
	return HAWK_BECS_PTR(mbuf);
}

#if defined(_WIN32) && !defined(INVALID_FILE_ATTRIBUTES)
#define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
#endif

static int upath_exists (hawk_gem_t* g, const hawk_uch_t* name, hawk_becs_t* mbuf)
{
#if defined(_WIN32)
	return (GetFileAttributesW(name) != INVALID_FILE_ATTRIBUTES)? 1: 0;

#elif defined(__OS2__)
	FILESTATUS3 fs;
	APIRET rc;
	const hawk_bch_t* mptr;

	mptr = wcs_to_mbuf(g, name, mbuf);
	if (HAWK_UNLIKELY(!mptr)) return -1;

	rc = DosQueryPathInfo(mptr, FIL_STANDARD, &fs, HAWK_SIZEOF(fs));
	return (rc == NO_ERROR)? 1: ((rc == ERROR_PATH_NOT_FOUND)? 0: -1);

#elif defined(__DOS__)
	unsigned int x, attr;
	const hawk_bch_t* mptr;

	mptr = wcs_to_mbuf(g, name, mbuf);
	if (HAWK_UNLIKELY(!mptr)) return -1;

	x = _dos_getfileattr (mptr, &attr);
	return (x == 0)? 1: ((errno == ENOENT)? 0: -1);

#elif defined(macintosh)
	HFileInfo fpb;
	const hawk_bch_t* mptr;

	mptr = wcs_to_mbuf(g, name, mbuf);
	if (HAWK_UNLIKELY(!mptr)) return -1;

	HAWK_MEMSET (&fpb, 0, HAWK_SIZEOF(fpb));
	fpb.ioNamePtr = (unsigned char*)mptr;

	return (PBGetCatInfoSync ((CInfoPBRec*)&fpb) == noErr)? 1: 0;
#else
	struct stat st;
	const hawk_bch_t* mptr;
	int t;

	mptr = wcs_to_mbuf(g, name, mbuf);
	if (HAWK_UNLIKELY(!mptr)) return -1;

	#if defined(HAVE_LSTAT)
	t = HAWK_LSTAT(mptr, &st);
	#else
	t = HAWK_STAT(mptr, &st);/* use stat() if no lstat() is available. */
	#endif
	return (t == 0);
#endif
}

static int bpath_exists (hawk_gem_t* g, const hawk_bch_t* name, hawk_becs_t* mbuf)
{
#if defined(_WIN32)
	return (GetFileAttributesA(name) != INVALID_FILE_ATTRIBUTES)? 1: 0;
#elif defined(__OS2__)

	FILESTATUS3 fs;
	APIRET rc;
	rc = DosQueryPathInfo(name, FIL_STANDARD, &fs, HAWK_SIZEOF(fs));
	return (rc == NO_ERROR)? 1: ((rc == ERROR_PATH_NOT_FOUND)? 0: -1);

#elif defined(__DOS__)
	unsigned int x, attr;
	x = _dos_getfileattr(name, &attr);
	return (x == 0)? 1: ((errno == ENOENT)? 0: -1);

#elif defined(macintosh)
	HFileInfo fpb;
	HAWK_MEMSET (&fpb, 0, HAWK_SIZEOF(fpb));
	fpb.ioNamePtr = (unsigned char*)name;
	return (PBGetCatInfoSync((CInfoPBRec*)&fpb) == noErr)? 1: 0;
#else
	struct stat st;
	int t;
	#if defined(HAVE_LSTAT)
	t = HAWK_LSTAT(name, &st);
	#else
	t = HAWK_STAT(name, &st); /* use stat() if no lstat() is available. */
	#endif
	return (t == 0);
#endif
}




#if defined(NO_RECURSION)
typedef struct __u_stack_node_t __u_stack_node_t;
#endif

struct __u_glob_t
{
	hawk_gem_uglob_cb_t cbimpl;
	void* cbctx;

	hawk_gem_t* gem;
	int flags;

	hawk_uecs_t path;
	hawk_uecs_t tbuf; /* temporary buffer */

	hawk_becs_t mbuf; /* not used if the base character type is hawk_bch_t */

	int expanded;
	int fnmat_flags;

#if defined(NO_RECURSION)
	__u_stack_node_t* stack;
	__u_stack_node_t* free;
#endif
};

typedef struct __u_glob_t __u_glob_t;

struct __u_segment_t
{
	segment_type_t type;

	const hawk_uch_t* ptr;
	hawk_oow_t    len;

	hawk_uch_t sep; /* preceeding separator */
	unsigned int wild: 1;  /* indicate that it contains wildcards */
	unsigned int esc: 1;  /* indicate that it contains escaped letters */
	unsigned int next: 1;  /* indicate that it has the following segment */
};
typedef struct __u_segment_t __u_segment_t;

#if defined(NO_RECURSION)
struct __u_stack_node_t
{
	hawk_oow_t tmp;
	hawk_oow_t tmp2;
	hawk_dir_t* dp;
	__u_segment_t seg;
	__u_stack_node_t* next;
};
#endif

static int __u_get_next_segment (__u_glob_t* g, __u_segment_t* seg)
{
	if (seg->type == NONE)
	{
		/* seg->ptr must point to the beginning of the pattern
		 * and seg->len must be zero when seg->type is NONE. */
		if (IS_NIL(seg->ptr[0]))
		{
			/* nothing to do */
		}
		else if (IS_SEP(seg->ptr[0]))
		{
			seg->type = ROOT;
			seg->len = 1;
			seg->next = IS_NIL(seg->ptr[1])? 0: 1;
			seg->sep = '\0';
			seg->wild = 0;
			seg->esc = 0;
		}
	#if defined(_WIN32) || defined(__OS2__) || defined(__DOS__)
		else if (IS_DRIVE(seg->ptr))
		{
			seg->type = ROOT;
			seg->len = 2;
			if (IS_SEP(seg->ptr[2])) seg->len++;
			seg->next = IS_NIL(seg->ptr[seg->len])? 0: 1;
			seg->sep = '\0';
			seg->wild = 0;
			seg->esc = 0;
		}
	#endif
		else
		{
			int escaped = 0;
			seg->type = NORMAL;
			seg->sep = '\0';
			seg->wild = 0;
			seg->esc = 0;
			do
			{
				if (escaped) escaped = 0;
				else
				{
					if (IS_ESC(seg->ptr[seg->len]))
					{
						escaped = 1;
						seg->esc = 1;
					}
					else if (IS_WILD(seg->ptr[seg->len])) seg->wild = 1;
				}

				seg->len++;
			}
			while (!IS_SEP_OR_NIL(seg->ptr[seg->len]));
			seg->next = IS_NIL(seg->ptr[seg->len])? 0: 1;
		}
	}
	else if (seg->type == ROOT)
	{
		int escaped = 0;
		seg->type = NORMAL;
		seg->ptr = &seg->ptr[seg->len];
		seg->len = 0;
		seg->sep = '\0';
		seg->wild = 0;
		seg->esc = 0;

		while (!IS_SEP_OR_NIL(seg->ptr[seg->len]))
		{
			if (escaped) escaped = 0;
			else
			{
				if (IS_ESC(seg->ptr[seg->len]))
				{
					escaped = 1;
					seg->esc = 1;
				}
				else if (IS_WILD(seg->ptr[seg->len])) seg->wild = 1;
			}
			seg->len++;
		}
		seg->next = IS_NIL(seg->ptr[seg->len])? 0: 1;
	}
	else
	{
		HAWK_ASSERT (seg->type == NORMAL);

		seg->ptr = &seg->ptr[seg->len + 1];
		seg->len = 0;
		seg->wild = 0;
		seg->esc = 0;
		if (IS_NIL(seg->ptr[-1]))
		{
			seg->type = NONE;
			seg->next = 0;
			seg->sep = '\0';
		}
		else
		{
			int escaped = 0;
			seg->sep = seg->ptr[-1];
			while (!IS_SEP_OR_NIL(seg->ptr[seg->len]))
			{
				if (escaped) escaped = 0;
				else
				{
					if (IS_ESC(seg->ptr[seg->len]))
					{
						escaped = 1;
						seg->esc = 1;
					}
					else if (IS_WILD(seg->ptr[seg->len])) seg->wild = 1;
				}
				seg->len++;
			}
			seg->next = IS_NIL(seg->ptr[seg->len])? 0: 1;
		}
	}

	return seg->type;
}

static int __u_handle_non_wild_segments (__u_glob_t* g, __u_segment_t* seg)
{
	while (__u_get_next_segment(g, seg) != NONE && !seg->wild)
	{
		HAWK_ASSERT (seg->type != NONE && !seg->wild);

		if (seg->sep && hawk_uecs_ccat (&g->path, seg->sep) == (hawk_oow_t)-1) return -1;
		if (seg->esc)
		{
			/* if the segment contains escape sequences,
			 * strip the escape letters off the segment */


			hawk_ucs_t tmp;
			hawk_oow_t i;
			int escaped = 0;

			if (HAWK_UECS_CAPA(&g->tbuf) < seg->len &&
			    hawk_uecs_setcapa (&g->tbuf, seg->len) == (hawk_oow_t)-1) return -1;

			tmp.ptr = HAWK_UECS_PTR(&g->tbuf);
			tmp.len = 0;

			/* the following loop drops the last character
			 * if it is the escape character */
			for (i = 0; i < seg->len; i++)
			{
				if (escaped)
				{
					escaped = 0;
					tmp.ptr[tmp.len++] = seg->ptr[i];
				}
				else
				{
					if (IS_ESC(seg->ptr[i]))
						escaped = 1;
					else
						tmp.ptr[tmp.len++] = seg->ptr[i];
				}
			}

			if (hawk_uecs_ncat (&g->path, tmp.ptr, tmp.len) == (hawk_oow_t)-1) return -1;
		}
		else
		{
			/* if the segment doesn't contain escape sequences,
			 * append the segment to the path without special handling */
			if (hawk_uecs_ncat (&g->path, seg->ptr, seg->len) == (hawk_oow_t)-1) return -1;
		}

		if (!seg->next && upath_exists(g->gem, HAWK_UECS_PTR(&g->path), &g->mbuf) > 0)
		{
			/* reached the last segment. match if the path exists */
			if (g->cbimpl(HAWK_UECS_CS(&g->path), g->cbctx) <= -1) return -1;
			g->expanded = 1;
		}
	}

	return 0;
}

static int __u_search (__u_glob_t* g, __u_segment_t* seg)
{
	hawk_dir_t* dp;
	hawk_oow_t tmp, tmp2;
	hawk_dir_ent_t ent;
	int x;

#if defined(NO_RECURSION)
	__u_stack_node_t* r;

entry:
#endif

	dp = HAWK_NULL;

	if (__u_handle_non_wild_segments(g, seg) <= -1) goto oops;

	if (seg->wild)
	{
		int dir_flags = 0;
		if (g->flags & HAWK_GLOB_SKIPSPCDIR) dir_flags |= HAWK_DIR_SKIPSPCDIR;
		if (HAWK_SIZEOF(hawk_uch_t) == HAWK_SIZEOF(hawk_bch_t)) dir_flags |= HAWK_DIR_BPATH;

		dp = hawk_dir_open(g->gem, 0, (const hawk_uch_t*)HAWK_UECS_PTR(&g->path), dir_flags);
		if (dp)
		{
			tmp = HAWK_UECS_LEN(&g->path);

			if (seg->sep && hawk_uecs_ccat(&g->path, seg->sep) == (hawk_oow_t)-1) goto oops;
			tmp2 = HAWK_UECS_LEN(&g->path);

			while (1)
			{
				hawk_uecs_setlen (&g->path, tmp2);

				x = hawk_dir_read(dp, &ent);
				if (x <= -1)
				{
					if (g->flags & HAWK_GLOB_TOLERANT) break;
					else goto oops;
				}
				if (x == 0) break;

				if (hawk_uecs_cat(&g->path, (const hawk_uch_t*)ent.name) == (hawk_oow_t)-1) goto oops;

				if (hawk_fnmat_ucstr_uchars(HAWK_UECS_CPTR(&g->path,tmp2), seg->ptr, seg->len, g->fnmat_flags) > 0)
				{
					if (seg->next)
					{
				#if defined(NO_RECURSION)
						if (g->free)
						{
							r = g->free;
							g->free = r->next;
						}
						else
						{
							r = hawk_gem_allocmem(g->gem, HAWK_SIZEOF(*r));
							if (r == HAWK_NULL) goto oops;
						}

						/* push key variables that must be restored
						 * into the stack. */
						r->tmp = tmp;
						r->tmp2 = tmp2;
						r->dp = dp;
						r->seg = *seg;

						r->next = g->stack;
						g->stack = r;

						/* move to the function entry point as if
						 * a recursive call has been made */
						goto entry;

					resume:
						;

				#else
						__u_segment_t save;
						int x;

						save = *seg;
						x = __u_search(g, seg);
						*seg = save;
						if (x <= -1) goto oops;
				#endif
					}
					else
					{
						if (g->cbimpl(HAWK_UECS_CS(&g->path), g->cbctx) <= -1) goto oops;
						g->expanded = 1;
					}
				}
			}

			hawk_uecs_setlen (&g->path, tmp);
			hawk_dir_close (dp); dp = HAWK_NULL;
		}
	}

	HAWK_ASSERT (dp == HAWK_NULL);

#if defined(NO_RECURSION)
	if (g->stack)
	{
		/* the stack is not empty. the emulated recusive call
		 * must have been made. restore the variables pushed
		 * and jump to the resumption point */
		r = g->stack;
		g->stack = r->next;

		tmp = r->tmp;
		tmp2 = r->tmp2;
		dp = r->dp;
		*seg = r->seg;

		/* link the stack node to the free list
		 * instead of freeing it here */
		r->next = g->free;
		g->free = r;

		goto resume;
	}

	while (g->free)
	{
		/* destory the free list */
		r = g->free;
		g->free = r->next;
		hawk_gem_freemem (g->gem, r);
	}
#endif

	return 0;

oops:
	if (dp) hawk_dir_close (dp);

#if defined(NO_RECURSION)
	while (g->stack)
	{
		r = g->stack;
		g->stack = r->next;
		hawk_dir_close (r->dp);
		hawk_gem_freemem (g->gem, r);
	}

	while (g->free)
	{
		r = g->stack;
		g->free = r->next;
		hawk_gem_freemem (g->gem, r);
	}
#endif
	return -1;
}

int hawk_gem_uglob (hawk_gem_t* gem, const hawk_uch_t* pattern, hawk_gem_uglob_cb_t cbimpl, void* cbctx, int flags)
{
	__u_segment_t seg;
	__u_glob_t g;
	int x;

	HAWK_MEMSET (&g, 0, HAWK_SIZEOF(g));
	g.gem = gem;
	g.cbimpl = cbimpl;
	g.cbctx = cbctx;
	g.flags = flags;

#if defined(_WIN32) || defined(__OS2__) || defined(__DOS__)
	g.fnmat_flags |= HAWK_FNMAT_IGNORECASE;
	g.fnmat_flags |= HAWK_FNMAT_NOESCAPE;
#else
	if (flags & HAWK_GLOB_IGNORECASE) g.fnmat_flags |= HAWK_FNMAT_IGNORECASE;
	if (flags & HAWK_GLOB_NOESCAPE) g.fnmat_flags |= HAWK_FNMAT_NOESCAPE;
#endif
	if (flags & HAWK_GLOB_PERIOD) g.fnmat_flags |= HAWK_FNMAT_PERIOD;

	if (hawk_uecs_init(&g.path, g.gem, 512) <= -1) return -1;
	if (hawk_uecs_init(&g.tbuf, g.gem, 256) <= -1)
	{
		hawk_uecs_fini (&g.path);
		return -1;
	}

	if (HAWK_SIZEOF(hawk_uch_t) != HAWK_SIZEOF(hawk_bch_t))
	{
		if (hawk_becs_init(&g.mbuf, g.gem, 512) <= -1)
		{
			hawk_uecs_fini (&g.path);
			hawk_uecs_fini (&g.path);
			return -1;
		}
	}

	HAWK_MEMSET (&seg, 0, HAWK_SIZEOF(seg));
	seg.type = NONE;
	seg.ptr = pattern;
	seg.len = 0;

	x = __u_search(&g, &seg);

	if (HAWK_SIZEOF(hawk_uch_t) != HAWK_SIZEOF(hawk_uch_t)) hawk_becs_fini (&g.mbuf);
	hawk_uecs_fini (&g.tbuf);
	hawk_uecs_fini (&g.path);

	if (x <= -1) return -1;
	return g.expanded;
}




#if defined(NO_RECURSION)
typedef struct __b_stack_node_t __b_stack_node_t;
#endif

struct __b_glob_t
{
	hawk_gem_bglob_cb_t cbimpl;
	void* cbctx;

	hawk_gem_t* gem;
	int flags;

	hawk_becs_t path;
	hawk_becs_t tbuf; /* temporary buffer */

	hawk_becs_t mbuf; /* not used if the base character type is hawk_bch_t */

	int expanded;
	int fnmat_flags;

#if defined(NO_RECURSION)
	__b_stack_node_t* stack;
	__b_stack_node_t* free;
#endif
};

typedef struct __b_glob_t __b_glob_t;

struct __b_segment_t
{
	segment_type_t type;

	const hawk_bch_t* ptr;
	hawk_oow_t    len;

	hawk_bch_t sep; /* preceeding separator */
	unsigned int wild: 1;  /* indicate that it contains wildcards */
	unsigned int esc: 1;  /* indicate that it contains escaped letters */
	unsigned int next: 1;  /* indicate that it has the following segment */
};
typedef struct __b_segment_t __b_segment_t;

#if defined(NO_RECURSION)
struct __b_stack_node_t
{
	hawk_oow_t tmp;
	hawk_oow_t tmp2;
	hawk_dir_t* dp;
	__b_segment_t seg;
	__b_stack_node_t* next;
};
#endif

static int __b_get_next_segment (__b_glob_t* g, __b_segment_t* seg)
{
	if (seg->type == NONE)
	{
		/* seg->ptr must point to the beginning of the pattern
		 * and seg->len must be zero when seg->type is NONE. */
		if (IS_NIL(seg->ptr[0]))
		{
			/* nothing to do */
		}
		else if (IS_SEP(seg->ptr[0]))
		{
			seg->type = ROOT;
			seg->len = 1;
			seg->next = IS_NIL(seg->ptr[1])? 0: 1;
			seg->sep = '\0';
			seg->wild = 0;
			seg->esc = 0;
		}
	#if defined(_WIN32) || defined(__OS2__) || defined(__DOS__)
		else if (IS_DRIVE(seg->ptr))
		{
			seg->type = ROOT;
			seg->len = 2;
			if (IS_SEP(seg->ptr[2])) seg->len++;
			seg->next = IS_NIL(seg->ptr[seg->len])? 0: 1;
			seg->sep = '\0';
			seg->wild = 0;
			seg->esc = 0;
		}
	#endif
		else
		{
			int escaped = 0;
			seg->type = NORMAL;
			seg->sep = '\0';
			seg->wild = 0;
			seg->esc = 0;
			do
			{
				if (escaped) escaped = 0;
				else
				{
					if (IS_ESC(seg->ptr[seg->len]))
					{
						escaped = 1;
						seg->esc = 1;
					}
					else if (IS_WILD(seg->ptr[seg->len])) seg->wild = 1;
				}

				seg->len++;
			}
			while (!IS_SEP_OR_NIL(seg->ptr[seg->len]));
			seg->next = IS_NIL(seg->ptr[seg->len])? 0: 1;
		}
	}
	else if (seg->type == ROOT)
	{
		int escaped = 0;
		seg->type = NORMAL;
		seg->ptr = &seg->ptr[seg->len];
		seg->len = 0;
		seg->sep = '\0';
		seg->wild = 0;
		seg->esc = 0;

		while (!IS_SEP_OR_NIL(seg->ptr[seg->len]))
		{
			if (escaped) escaped = 0;
			else
			{
				if (IS_ESC(seg->ptr[seg->len]))
				{
					escaped = 1;
					seg->esc = 1;
				}
				else if (IS_WILD(seg->ptr[seg->len])) seg->wild = 1;
			}
			seg->len++;
		}
		seg->next = IS_NIL(seg->ptr[seg->len])? 0: 1;
	}
	else
	{
		HAWK_ASSERT (seg->type == NORMAL);

		seg->ptr = &seg->ptr[seg->len + 1];
		seg->len = 0;
		seg->wild = 0;
		seg->esc = 0;
		if (IS_NIL(seg->ptr[-1]))
		{
			seg->type = NONE;
			seg->next = 0;
			seg->sep = '\0';
		}
		else
		{
			int escaped = 0;
			seg->sep = seg->ptr[-1];
			while (!IS_SEP_OR_NIL(seg->ptr[seg->len]))
			{
				if (escaped) escaped = 0;
				else
				{
					if (IS_ESC(seg->ptr[seg->len]))
					{
						escaped = 1;
						seg->esc = 1;
					}
					else if (IS_WILD(seg->ptr[seg->len])) seg->wild = 1;
				}
				seg->len++;
			}
			seg->next = IS_NIL(seg->ptr[seg->len])? 0: 1;
		}
	}

	return seg->type;
}

static int __b_handle_non_wild_segments (__b_glob_t* g, __b_segment_t* seg)
{
	while (__b_get_next_segment(g, seg) != NONE && !seg->wild)
	{
		HAWK_ASSERT (seg->type != NONE && !seg->wild);

		if (seg->sep && hawk_becs_ccat (&g->path, seg->sep) == (hawk_oow_t)-1) return -1;
		if (seg->esc)
		{
			/* if the segment contains escape sequences,
			 * strip the escape letters off the segment */


			hawk_bcs_t tmp;
			hawk_oow_t i;
			int escaped = 0;

			if (HAWK_BECS_CAPA(&g->tbuf) < seg->len &&
			    hawk_becs_setcapa (&g->tbuf, seg->len) == (hawk_oow_t)-1) return -1;

			tmp.ptr = HAWK_BECS_PTR(&g->tbuf);
			tmp.len = 0;

			/* the following loop drops the last character
			 * if it is the escape character */
			for (i = 0; i < seg->len; i++)
			{
				if (escaped)
				{
					escaped = 0;
					tmp.ptr[tmp.len++] = seg->ptr[i];
				}
				else
				{
					if (IS_ESC(seg->ptr[i]))
						escaped = 1;
					else
						tmp.ptr[tmp.len++] = seg->ptr[i];
				}
			}

			if (hawk_becs_ncat (&g->path, tmp.ptr, tmp.len) == (hawk_oow_t)-1) return -1;
		}
		else
		{
			/* if the segment doesn't contain escape sequences,
			 * append the segment to the path without special handling */
			if (hawk_becs_ncat (&g->path, seg->ptr, seg->len) == (hawk_oow_t)-1) return -1;
		}

		if (!seg->next && bpath_exists(g->gem, HAWK_BECS_PTR(&g->path), &g->mbuf) > 0)
		{
			/* reached the last segment. match if the path exists */
			if (g->cbimpl(HAWK_BECS_CS(&g->path), g->cbctx) <= -1) return -1;
			g->expanded = 1;
		}
	}

	return 0;
}

static int __b_search (__b_glob_t* g, __b_segment_t* seg)
{
	hawk_dir_t* dp;
	hawk_oow_t tmp, tmp2;
	hawk_dir_ent_t ent;
	int x;

#if defined(NO_RECURSION)
	__b_stack_node_t* r;

entry:
#endif

	dp = HAWK_NULL;

	if (__b_handle_non_wild_segments(g, seg) <= -1) goto oops;

	if (seg->wild)
	{
		int dir_flags = 0;
		if (g->flags & HAWK_GLOB_SKIPSPCDIR) dir_flags |= HAWK_DIR_SKIPSPCDIR;
		if (HAWK_SIZEOF(hawk_bch_t) == HAWK_SIZEOF(hawk_bch_t)) dir_flags |= HAWK_DIR_BPATH;

		dp = hawk_dir_open(g->gem, 0, (const hawk_bch_t*)HAWK_BECS_PTR(&g->path), dir_flags);
		if (dp)
		{
			tmp = HAWK_BECS_LEN(&g->path);

			if (seg->sep && hawk_becs_ccat(&g->path, seg->sep) == (hawk_oow_t)-1) goto oops;
			tmp2 = HAWK_BECS_LEN(&g->path);

			while (1)
			{
				hawk_becs_setlen (&g->path, tmp2);

				x = hawk_dir_read(dp, &ent);
				if (x <= -1)
				{
					if (g->flags & HAWK_GLOB_TOLERANT) break;
					else goto oops;
				}
				if (x == 0) break;

				if (hawk_becs_cat(&g->path, (const hawk_bch_t*)ent.name) == (hawk_oow_t)-1) goto oops;

				if (hawk_fnmat_bcstr_bchars(HAWK_BECS_CPTR(&g->path,tmp2), seg->ptr, seg->len, g->fnmat_flags) > 0)
				{
					if (seg->next)
					{
				#if defined(NO_RECURSION)
						if (g->free)
						{
							r = g->free;
							g->free = r->next;
						}
						else
						{
							r = hawk_gem_allocmem(g->gem, HAWK_SIZEOF(*r));
							if (r == HAWK_NULL) goto oops;
						}

						/* push key variables that must be restored
						 * into the stack. */
						r->tmp = tmp;
						r->tmp2 = tmp2;
						r->dp = dp;
						r->seg = *seg;

						r->next = g->stack;
						g->stack = r;

						/* move to the function entry point as if
						 * a recursive call has been made */
						goto entry;

					resume:
						;

				#else
						__b_segment_t save;
						int x;

						save = *seg;
						x = __b_search(g, seg);
						*seg = save;
						if (x <= -1) goto oops;
				#endif
					}
					else
					{
						if (g->cbimpl(HAWK_BECS_CS(&g->path), g->cbctx) <= -1) goto oops;
						g->expanded = 1;
					}
				}
			}

			hawk_becs_setlen (&g->path, tmp);
			hawk_dir_close (dp); dp = HAWK_NULL;
		}
	}

	HAWK_ASSERT (dp == HAWK_NULL);

#if defined(NO_RECURSION)
	if (g->stack)
	{
		/* the stack is not empty. the emulated recusive call
		 * must have been made. restore the variables pushed
		 * and jump to the resumption point */
		r = g->stack;
		g->stack = r->next;

		tmp = r->tmp;
		tmp2 = r->tmp2;
		dp = r->dp;
		*seg = r->seg;

		/* link the stack node to the free list
		 * instead of freeing it here */
		r->next = g->free;
		g->free = r;

		goto resume;
	}

	while (g->free)
	{
		/* destory the free list */
		r = g->free;
		g->free = r->next;
		hawk_gem_freemem (g->gem, r);
	}
#endif

	return 0;

oops:
	if (dp) hawk_dir_close (dp);

#if defined(NO_RECURSION)
	while (g->stack)
	{
		r = g->stack;
		g->stack = r->next;
		hawk_dir_close (r->dp);
		hawk_gem_freemem (g->gem, r);
	}

	while (g->free)
	{
		r = g->stack;
		g->free = r->next;
		hawk_gem_freemem (g->gem, r);
	}
#endif
	return -1;
}

int hawk_gem_bglob (hawk_gem_t* gem, const hawk_bch_t* pattern, hawk_gem_bglob_cb_t cbimpl, void* cbctx, int flags)
{
	__b_segment_t seg;
	__b_glob_t g;
	int x;

	HAWK_MEMSET (&g, 0, HAWK_SIZEOF(g));
	g.gem = gem;
	g.cbimpl = cbimpl;
	g.cbctx = cbctx;
	g.flags = flags;

#if defined(_WIN32) || defined(__OS2__) || defined(__DOS__)
	g.fnmat_flags |= HAWK_FNMAT_IGNORECASE;
	g.fnmat_flags |= HAWK_FNMAT_NOESCAPE;
#else
	if (flags & HAWK_GLOB_IGNORECASE) g.fnmat_flags |= HAWK_FNMAT_IGNORECASE;
	if (flags & HAWK_GLOB_NOESCAPE) g.fnmat_flags |= HAWK_FNMAT_NOESCAPE;
#endif
	if (flags & HAWK_GLOB_PERIOD) g.fnmat_flags |= HAWK_FNMAT_PERIOD;

	if (hawk_becs_init(&g.path, g.gem, 512) <= -1) return -1;
	if (hawk_becs_init(&g.tbuf, g.gem, 256) <= -1)
	{
		hawk_becs_fini (&g.path);
		return -1;
	}

	if (HAWK_SIZEOF(hawk_bch_t) != HAWK_SIZEOF(hawk_bch_t))
	{
		if (hawk_becs_init(&g.mbuf, g.gem, 512) <= -1)
		{
			hawk_becs_fini (&g.path);
			hawk_becs_fini (&g.path);
			return -1;
		}
	}

	HAWK_MEMSET (&seg, 0, HAWK_SIZEOF(seg));
	seg.type = NONE;
	seg.ptr = pattern;
	seg.len = 0;

	x = __b_search(&g, &seg);

	if (HAWK_SIZEOF(hawk_bch_t) != HAWK_SIZEOF(hawk_uch_t)) hawk_becs_fini (&g.mbuf);
	hawk_becs_fini (&g.tbuf);
	hawk_becs_fini (&g.path);

	if (x <= -1) return -1;
	return g.expanded;
}