openadk/package/heirloom-cpio/src/regexp.h

/*
 * Simple Regular Expression functions. Derived from Unix 7th Edition,
 * /usr/src/cmd/expr.y
 *
 * Modified by Gunnar Ritter, Freiburg i. Br., Germany, February 2002.
 *
 * Copyright(C) Caldera International Inc. 2001-2002. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *   Redistributions of source code and documentation must retain the
 *    above copyright notice, this list of conditions and the following
 *    disclaimer.
 *   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.
 *   All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed or owned by Caldera
 *      International, Inc.
 *   Neither the name of Caldera International, Inc. nor the names of
 *    other contributors may be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
 * INTERNATIONAL, INC. 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 CALDERA INTERNATIONAL, INC. 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.
 */

#if __GNUC__ >= 3 && __GNUC_MINOR__ >= 4 || __GNUC__ >= 4
#define	REGEXP_H_USED	__attribute__ ((used))
#elif defined __GNUC__
#define	REGEXP_H_USED	__attribute__ ((unused))
#else
#define	REGEXP_H_USED
#endif
static const char regexp_h_sccsid[] REGEXP_H_USED =
	"@(#)regexp.sl	1.56 (gritter) 5/29/05";

#if !defined (REGEXP_H_USED_FROM_VI) && !defined (__dietlibc__)
#define	REGEXP_H_WCHARS
#endif

#define	CBRA	2
#define	CCHR	4
#define	CDOT	8
#define	CCL	12
/*	CLNUM	14	used in sed */
/*	CEND	16	used in sed */
#define	CDOL	20
#define	CCEOF	22
#define	CKET	24
#define	CBACK	36
#define	CNCL	40
#define	CBRC	44
#define	CLET	48
#define	CCH1	52
#define	CCH2	56
#define	CCH3	60

#define	STAR	01
#define RNGE	03
#define	REGEXP_H_LEAST	0100

#ifdef	REGEXP_H_WCHARS
#define	CMB	0200
#else	/* !REGEXP_H_WCHARS */
#define	CMB	0
#endif	/* !REGEXP_H_WCHARS */

#define	NBRA	9

#define PLACE(c)	ep[c >> 3] |= bittab[c & 07]
#define ISTHERE(c)	(ep[c >> 3] & bittab[c & 07])

#ifdef	REGEXP_H_WCHARS
#define	REGEXP_H_IS_THERE(ep, c)	((ep)[c >> 3] & bittab[c & 07])
#endif

#include	<ctype.h>
#include	<string.h>
#include	<limits.h>
#ifdef	REGEXP_H_WCHARS
#include	<stdlib.h>
#include	<wchar.h>
#include	<wctype.h>
#endif	/* REGEXP_H_WCHARS */

#define	regexp_h_uletter(c)	(isalpha(c) || (c) == '_')
#ifdef	REGEXP_H_WCHARS
#define	regexp_h_wuletter(c)	(iswalpha(c) || (c) == L'_')

/*
 * Used to allocate memory for the multibyte star algorithm.
 */
#ifndef	regexp_h_malloc
#define	regexp_h_malloc(n)	malloc(n)
#endif
#ifndef	regexp_h_free
#define	regexp_h_free(p)	free(p)
#endif

/*
 * Can be predefined to 'inline' to inline some multibyte functions;
 * may improve performance for files that contain many multibyte
 * sequences.
 */
#ifndef	regexp_h_inline
#define	regexp_h_inline
#endif

/*
 * Mask to determine whether the first byte of a sequence possibly
 * starts a multibyte character. Set to 0377 to force mbtowc() for
 * any byte sequence (except 0).
 */
#ifndef	REGEXP_H_MASK
#define	REGEXP_H_MASK	0200
#endif
#endif	/* REGEXP_H_WCHARS */

/*
 * For regexpr.h.
 */
#ifndef	regexp_h_static
#define	regexp_h_static
#endif
#ifndef	REGEXP_H_STEP_INIT
#define	REGEXP_H_STEP_INIT
#endif
#ifndef	REGEXP_H_ADVANCE_INIT
#define	REGEXP_H_ADVANCE_INIT
#endif

char	*braslist[NBRA];
char	*braelist[NBRA];
int	nbra;
char	*loc1, *loc2, *locs;
int	sed;
int	nodelim;

regexp_h_static int	circf;
regexp_h_static int	low;
regexp_h_static int	size;

regexp_h_static unsigned char	bittab[] = {
	1,
	2,
	4,
	8,
	16,
	32,
	64,
	128
};
static int	regexp_h_advance(register const char *lp,
			register const char *ep);
static void	regexp_h_getrnge(register const char *str, int least);

static const char	*regexp_h_bol;	/* beginning of input line (for \<) */

#ifdef	REGEXP_H_WCHARS
static int	regexp_h_wchars;
static int	regexp_h_mbcurmax;

static const char	*regexp_h_firstwc;	/* location of first
						   multibyte character
						   on input line */

#define	regexp_h_getwc(c)	{ \
	if (regexp_h_wchars) { \
		char mbbuf[MB_LEN_MAX + 1], *mbptr; \
		wchar_t wcbuf; \
		int mb, len; \
		mbptr = mbbuf; \
		do { \
			mb = GETC(); \
			*mbptr++ = mb; \
			*mbptr = '\0'; \
		} while ((len = mbtowc(&wcbuf, mbbuf, regexp_h_mbcurmax)) < 0 \
			&& mb != eof && mbptr < mbbuf + MB_LEN_MAX); \
		if (len == -1) \
			ERROR(67); \
		c = wcbuf; \
	} else { \
		c = GETC(); \
	} \
}

#define	regexp_h_store(wc, mb, me)	{ \
	int len; \
	if (wc == WEOF) \
		ERROR(67); \
	if ((len = me - mb) <= regexp_h_mbcurmax) { \
		char mt[MB_LEN_MAX]; \
		if (wctomb(mt, wc) >= len) \
			ERROR(50); \
	} \
	switch (len = wctomb(mb, wc)) { \
	case -1: \
		 ERROR(67); \
	case 0: \
		mb++; \
		break; \
	default: \
		mb += len; \
	} \
}

static regexp_h_inline wint_t
regexp_h_fetchwc(const char **mb, int islp)
{
	wchar_t wc;
	int len;

	if ((len = mbtowc(&wc, *mb, regexp_h_mbcurmax)) < 0) {
		(*mb)++;
		return WEOF;
	}
	if (islp && regexp_h_firstwc == NULL)
		regexp_h_firstwc = *mb;
	/*if (len == 0) {
		(*mb)++;
		return L'\0';
	} handled in singlebyte code */
	*mb += len;
	return wc;
}

#define	regexp_h_fetch(mb, islp)	((*(mb) & REGEXP_H_MASK) == 0 ? \
						(*(mb)++&0377): \
						regexp_h_fetchwc(&(mb), islp))

static regexp_h_inline wint_t
regexp_h_showwc(const char *mb)
{
	wchar_t wc;

	if (mbtowc(&wc, mb, regexp_h_mbcurmax) < 0)
		return WEOF;
	return wc;
}

#define	regexp_h_show(mb)	((*(mb) & REGEXP_H_MASK) == 0 ? (*(mb)&0377): \
					regexp_h_showwc(mb))

/*
 * Return the character immediately preceding mb. Since no byte is
 * required to be the first byte of a character, the longest multibyte
 * character ending at &[mb-1] is searched.
 */
static regexp_h_inline wint_t
regexp_h_previous(const char *mb)
{
	const char *p = mb;
	wchar_t wc, lastwc = WEOF;
	int len, max = 0;

	if (regexp_h_firstwc == NULL || mb <= regexp_h_firstwc)
		return (mb > regexp_h_bol ? (mb[-1] & 0377) : WEOF);
	while (p-- > regexp_h_bol) {
		mbtowc(NULL, NULL, 0);
		if ((len = mbtowc(&wc, p, mb - p)) >= 0) {
			if (len < max || len < mb - p)
				break;
			max = len;
			lastwc = wc;
		} else if (len < 0 && max > 0)
			break;
	}
	return lastwc;
}

#define	regexp_h_cclass(set, c, af)	\
	((c) == 0 || (c) == WEOF ? 0 : ( \
		((c) > 0177) ? \
			regexp_h_cclass_wc(set, c, af) : ( \
				REGEXP_H_IS_THERE((set)+1, (c)) ? (af) : !(af) \
			) \
		) \
	)

static regexp_h_inline int
regexp_h_cclass_wc(const char *set, register wint_t c, int af)
{
	register wint_t wc, wl = WEOF;
	const char *end;

	end = &set[18] + set[0] - 1;
	set += 17;
	while (set < end) {
		wc = regexp_h_fetch(set, 0);
#ifdef	REGEXP_H_VI_BACKSLASH
		if (wc == '\\' && set < end &&
				(*set == ']' || *set == '-' ||
				 *set == '^' || *set == '\\')) {
			wc = regexp_h_fetch(set, 0);
		} else
#endif	/* REGEXP_H_VI_BACKSLASH */
		if (wc == '-' && wl != WEOF && set < end) {
			wc = regexp_h_fetch(set, 0);
#ifdef	REGEXP_H_VI_BACKSLASH
			if (wc == '\\' && set < end &&
					(*set == ']' || *set == '-' ||
					 *set == '^' || *set == '\\')) {
				wc = regexp_h_fetch(set, 0);
			}
#endif	/* REGEXP_H_VI_BACKSLASH */
			if (c > wl && c < wc)
				return af;
		}
		if (c == wc)
			return af;
		wl = wc;
	}
	return !af;
}
#else	/* !REGEXP_H_WCHARS */
#define	regexp_h_wchars		0
#define	regexp_h_getwc(c)	{ c = GETC(); }
#endif	/* !REGEXP_H_WCHARS */

regexp_h_static char *
compile(char *instring, char *ep, const char *endbuf, int seof)
{
	INIT	/* Dependent declarations and initializations */
	register int c;
	register int eof = seof;
	char *lastep = instring;
	int cclcnt;
	char bracket[NBRA], *bracketp;
	int closed;
	char neg;
	int lc;
	int i, cflg;

#ifdef	REGEXP_H_WCHARS
	char *eq;
	regexp_h_mbcurmax = MB_CUR_MAX;
	regexp_h_wchars = regexp_h_mbcurmax > 1 ? CMB : 0;
#endif
	lastep = 0;
	bracketp = bracket;
	if((c = GETC()) == eof || c == '\n') {
		if (c == '\n') {
			UNGETC(c);
			nodelim = 1;
		}
		if(*ep == 0 && !sed)
			ERROR(41);
		if (bracketp > bracket)
			ERROR(42);
		RETURN(ep);
	}
	circf = closed = nbra = 0;
	if (c == '^')
		circf++;
	else
		UNGETC(c);
	for (;;) {
		if (ep >= endbuf)
			ERROR(50);
		regexp_h_getwc(c);
		if(c != '*' && ((c != '\\') || (PEEKC() != '{')))
			lastep = ep;
		if (c == eof) {
			*ep++ = CCEOF;
			if (bracketp > bracket)
				ERROR(42);
			RETURN(ep);
		}
		switch (c) {

		case '.':
			*ep++ = CDOT|regexp_h_wchars;
			continue;

		case '\n':
			if (sed == 0) {
				UNGETC(c);
				*ep++ = CCEOF;
				nodelim = 1;
				RETURN(ep);
			}
			ERROR(36);
		case '*':
			if (lastep==0 || *lastep==CBRA || *lastep==CKET ||
					*lastep==(CBRC|regexp_h_wchars) ||
					*lastep==(CLET|regexp_h_wchars))
				goto defchar;
			*lastep |= STAR;
			continue;

		case '$':
			if(PEEKC() != eof)
				goto defchar;
			*ep++ = CDOL;
			continue;

		case '[':
#ifdef	REGEXP_H_WCHARS
			if (regexp_h_wchars == 0) {
#endif
				if(&ep[33] >= endbuf)
					ERROR(50);

				*ep++ = CCL;
				lc = 0;
				for(i = 0; i < 32; i++)
					ep[i] = 0;

				neg = 0;
				if((c = GETC()) == '^') {
					neg = 1;
					c = GETC();
				}

				do {
					c &= 0377;
					if(c == '\0' || c == '\n')
						ERROR(49);
#ifdef	REGEXP_H_VI_BACKSLASH
					if(c == '\\' && ((c = PEEKC()) == ']' ||
							c == '-' || c == '^' ||
							c == '\\')) {
						c = GETC();
						c &= 0377;
					} else
#endif	/* REGEXP_H_VI_BACKSLASH */
					if(c == '-' && lc != 0) {
						if ((c = GETC()) == ']') {
							PLACE('-');
							break;
						}
#ifdef	REGEXP_H_VI_BACKSLASH
						if(c == '\\' &&
							((c = PEEKC()) == ']' ||
								c == '-' ||
								c == '^' ||
								c == '\\'))
							c = GETC();
#endif	/* REGEXP_H_VI_BACKSLASH */
						c &= 0377;
						while(lc < c) {
							PLACE(lc);
							lc++;
						}
					}
					lc = c;
					PLACE(c);
				} while((c = GETC()) != ']');
				if(neg) {
					for(cclcnt = 0; cclcnt < 32; cclcnt++)
						ep[cclcnt] ^= 0377;
					ep[0] &= 0376;
				}

				ep += 32;
#ifdef	REGEXP_H_WCHARS
			} else {
				if (&ep[18] >= endbuf)
					ERROR(50);
				*ep++ = CCL|CMB;
				*ep++ = 0;
				lc = 0;
				for (i = 0; i < 16; i++)
					ep[i] = 0;
				eq = &ep[16];
				regexp_h_getwc(c);
				if (c == L'^') {
					regexp_h_getwc(c);
					ep[-2] = CNCL|CMB;
				}
				do {
					if (c == '\0' || c == '\n')
						ERROR(49);
#ifdef	REGEXP_H_VI_BACKSLASH
					if(c == '\\' && ((c = PEEKC()) == ']' ||
							c == '-' || c == '^' ||
							c == '\\')) {
						regexp_h_store(c, eq, endbuf);
						regexp_h_getwc(c);
					} else
#endif	/* REGEXP_H_VI_BACKSLASH */
					if (c == '-' && lc != 0 && lc <= 0177) {
						regexp_h_store(c, eq, endbuf);
						regexp_h_getwc(c);
						if (c == ']') {
							PLACE('-');
							break;
						}
#ifdef	REGEXP_H_VI_BACKSLASH
						if(c == '\\' &&
							((c = PEEKC()) == ']' ||
								c == '-' ||
								c == '^' ||
								c == '\\')) {
							regexp_h_store(c, eq,
								endbuf);
							regexp_h_getwc(c);
						}
#endif	/* REGEXP_H_VI_BACKSLASH */
						while (lc < (c & 0177)) {
							PLACE(lc);
							lc++;
						}
					}
					lc = c;
					if (c <= 0177)
						PLACE(c);
					regexp_h_store(c, eq, endbuf);
					regexp_h_getwc(c);
				} while (c != L']');
				if ((i = eq - &ep[16]) > 255)
					ERROR(50);
				lastep[1] = i;
				ep = eq;
			}
#endif	/* REGEXP_H_WCHARS */

			continue;

		case '\\':
			regexp_h_getwc(c);
			switch(c) {

			case '(':
				if(nbra >= NBRA)
					ERROR(43);
				*bracketp++ = nbra;
				*ep++ = CBRA;
				*ep++ = nbra++;
				continue;

			case ')':
				if(bracketp <= bracket)
					ERROR(42);
				*ep++ = CKET;
				*ep++ = *--bracketp;
				closed++;
				continue;

			case '<':
				*ep++ = CBRC|regexp_h_wchars;
				continue;

			case '>':
				*ep++ = CLET|regexp_h_wchars;
				continue;

			case '{':
				if(lastep == (char *) (0))
					goto defchar;
				*lastep |= RNGE;
				cflg = 0;
			nlim:
				c = GETC();
				i = 0;
				do {
					if ('0' <= c && c <= '9')
						i = 10 * i + c - '0';
					else
						ERROR(16);
				} while(((c = GETC()) != '\\') && (c != ','));
				if (i > 255)
					ERROR(11);
				*ep++ = i;
				if (c == ',') {
					if(cflg++)
						ERROR(44);
					if((c = GETC()) == '\\') {
						*ep++ = (char)255;
						*lastep |= REGEXP_H_LEAST;
					} else {
						UNGETC(c);
						goto nlim; /* get 2'nd number */
					}
				}
				if(GETC() != '}')
					ERROR(45);
				if(!cflg)	/* one number */
					*ep++ = i;
				else if((ep[-1] & 0377) < (ep[-2] & 0377))
					ERROR(46);
				continue;

			case '\n':
				ERROR(36);

			case 'n':
				c = '\n';
				goto defchar;

			default:
				if(c >= '1' && c <= '9') {
					if((c -= '1') >= closed)
						ERROR(25);
					*ep++ = CBACK;
					*ep++ = c;
					continue;
				}
			}
			/* Drop through to default to use \ to turn off special chars */

		defchar:
		default:
			lastep = ep;
#ifdef	REGEXP_H_WCHARS
			if (regexp_h_wchars == 0) {
#endif
				*ep++ = CCHR;
				*ep++ = c;
#ifdef	REGEXP_H_WCHARS
			} else {
				char	mbbuf[MB_LEN_MAX];

				switch (wctomb(mbbuf, c)) {
				case 1: *ep++ = CCH1;
					break;
				case 2:	*ep++ = CCH2;
					break;
				case 3:	*ep++ = CCH3;
					break;
				default:
					*ep++ = CCHR|CMB;
				}
				regexp_h_store(c, ep, endbuf);
			}
#endif	/* REGEXP_H_WCHARS */
		}
	}
}

int
step(const char *p1, const char *p2)
{
	register int c;
#ifdef	REGEXP_H_WCHARS
	register int d;
#endif	/* REGEXP_H_WCHARS */

	REGEXP_H_STEP_INIT	/* get circf */
	regexp_h_bol = p1;
#ifdef	REGEXP_H_WCHARS
	regexp_h_firstwc = NULL;
#endif	/* REGEXP_H_WCHARS */
	if (circf) {
		loc1 = (char *)p1;
		return(regexp_h_advance(p1, p2));
	}
	/* fast check for first character */
	if (*p2==CCHR) {
		c = p2[1] & 0377;
		do {
			if ((*p1 & 0377) != c)
				continue;
			if (regexp_h_advance(p1, p2)) {
				loc1 = (char *)p1;
				return(1);
			}
		} while (*p1++);
		return(0);
	}
#ifdef	REGEXP_H_WCHARS
	else if (*p2==CCH1) {
		do {
			if (p1[0] == p2[1] && regexp_h_advance(p1, p2)) {
				loc1 = (char *)p1;
				return(1);
			}
			c = regexp_h_fetch(p1, 1);
		} while (c);
		return(0);
	} else if (*p2==CCH2) {
		do {
			if (p1[0] == p2[1] && p1[1] == p2[2] &&
					regexp_h_advance(p1, p2)) {
				loc1 = (char *)p1;
				return(1);
			}
			c = regexp_h_fetch(p1, 1);
		} while (c);
		return(0);
	} else if (*p2==CCH3) {
		do {
			if (p1[0] == p2[1] && p1[1] == p2[2] && p1[2] == p2[3]&&
					regexp_h_advance(p1, p2)) {
				loc1 = (char *)p1;
				return(1);
			}
			c = regexp_h_fetch(p1, 1);
		} while (c);
		return(0);
	} else if ((*p2&0377)==(CCHR|CMB)) {
		d = regexp_h_fetch(p2, 0);
		do {
			c = regexp_h_fetch(p1, 1);
			if (c == d && regexp_h_advance(p1, p2)) {
				loc1 = (char *)p1;
				return(1);
			}
		} while(c);
		return(0);
	}
		/* regular algorithm */
	if (regexp_h_wchars)
		do {
			if (regexp_h_advance(p1, p2)) {
				loc1 = (char *)p1;
				return(1);
			}
			c = regexp_h_fetch(p1, 1);
		} while (c);
	else
#endif	/* REGEXP_H_WCHARS */
		do {
			if (regexp_h_advance(p1, p2)) {
				loc1 = (char *)p1;
				return(1);
			}
		} while (*p1++);
	return(0);
}

#ifdef	REGEXP_H_WCHARS
/*
 * It is painfully slow to read character-wise backwards in a
 * multibyte string (see regexp_h_previous() above). For the star
 * algorithm, we therefore keep track of every character as it is
 * read in forward direction.
 *
 * Don't use alloca() for stack blocks since there is no measurable
 * speedup and huge amounts of memory are used up for long input
 * lines.
 */
#ifndef	REGEXP_H_STAKBLOK
#define	REGEXP_H_STAKBLOK	1000
#endif

struct	regexp_h_stack {
	struct regexp_h_stack	*s_nxt;
	struct regexp_h_stack	*s_prv;
	const char	*s_ptr[REGEXP_H_STAKBLOK];
};

#define	regexp_h_push(sb, sp, sc, lp)	(regexp_h_wchars ? \
			regexp_h_pushwc(sb, sp, sc, lp) : (void)0)

static regexp_h_inline void
regexp_h_pushwc(struct regexp_h_stack **sb,
		struct regexp_h_stack **sp,
		const char ***sc, const char *lp)
{
	if (regexp_h_firstwc == NULL || lp < regexp_h_firstwc)
		return;
	if (*sb == NULL) {
		if ((*sb = regexp_h_malloc(sizeof **sb)) == NULL)
			return;
		(*sb)->s_nxt = (*sb)->s_prv = NULL;
		*sp = *sb;
		*sc = &(*sb)->s_ptr[0];
	} else if (*sc >= &(*sp)->s_ptr[REGEXP_H_STAKBLOK]) {
		if ((*sp)->s_nxt == NULL) {
			struct regexp_h_stack	*bq;

			if ((bq = regexp_h_malloc(sizeof *bq)) == NULL)
				return;
			bq->s_nxt = NULL;
			bq->s_prv = *sp;
			(*sp)->s_nxt = bq;
			*sp = bq;
		} else
			*sp = (*sp)->s_nxt;
		*sc = &(*sp)->s_ptr[0];
	}
	*(*sc)++ = lp;
}

static regexp_h_inline const char *
regexp_h_pop(struct regexp_h_stack **sb, struct regexp_h_stack **sp,
		const char ***sc, const char *lp)
{
	if (regexp_h_firstwc == NULL || lp <= regexp_h_firstwc)
		return &lp[-1];
	if (*sp == NULL)
		return regexp_h_firstwc;
	if (*sc == &(*sp)->s_ptr[0]) {
		if ((*sp)->s_prv == NULL) {
			regexp_h_free(*sp);
			*sp = NULL;
			*sb = NULL;
			return regexp_h_firstwc;
		}
		*sp = (*sp)->s_prv;
		regexp_h_free((*sp)->s_nxt);
		(*sp)->s_nxt = NULL ;
		*sc = &(*sp)->s_ptr[REGEXP_H_STAKBLOK];
	}
	return *(--(*sc));
}

static void
regexp_h_zerostak(struct regexp_h_stack **sb, struct regexp_h_stack **sp)
{
	for (*sp = *sb; *sp && (*sp)->s_nxt; *sp = (*sp)->s_nxt)
		if ((*sp)->s_prv)
			regexp_h_free((*sp)->s_prv);
	if (*sp) {
		if ((*sp)->s_prv)
			regexp_h_free((*sp)->s_prv);
		regexp_h_free(*sp);
	}
	*sp = *sb = NULL;
}
#else	/* !REGEXP_H_WCHARS */
#define	regexp_h_push(sb, sp, sc, lp)
#endif	/* !REGEXP_H_WCHARS */

static int
regexp_h_advance(const char *lp, const char *ep)
{
	register const char *curlp;
	int c, least;
#ifdef	REGEXP_H_WCHARS
	int d;
	struct regexp_h_stack	*sb = NULL, *sp = NULL;
	const char	**sc;
#endif	/* REGEXP_H_WCHARS */
	char *bbeg;
	int ct;

	for (;;) switch (least = *ep++ & 0377, least & ~REGEXP_H_LEAST) {

	case CCHR:
#ifdef	REGEXP_H_WCHARS
	case CCH1:
#endif
		if (*ep++ == *lp++)
			continue;
		return(0);

#ifdef	REGEXP_H_WCHARS
	case CCHR|CMB:
		if (regexp_h_fetch(ep, 0) == regexp_h_fetch(lp, 1))
			continue;
		return(0);

	case CCH2:
		if (ep[0] == lp[0] && ep[1] == lp[1]) {
			ep += 2, lp += 2;
			continue;
		}
		return(0);

	case CCH3:
		if (ep[0] == lp[0] && ep[1] == lp[1] && ep[2] == lp[2]) {
			ep += 3, lp += 3;
			continue;
		}
		return(0);
#endif	/* REGEXP_H_WCHARS */

	case CDOT:
		if (*lp++)
			continue;
		return(0);
#ifdef	REGEXP_H_WCHARS
	case CDOT|CMB:
		if ((c = regexp_h_fetch(lp, 1)) != L'\0' && c != WEOF)
			continue;
		return(0);
#endif	/* REGEXP_H_WCHARS */

	case CDOL:
		if (*lp==0)
			continue;
		return(0);

	case CCEOF:
		loc2 = (char *)lp;
		return(1);

	case CCL:
		c = *lp++ & 0377;
		if(ISTHERE(c)) {
			ep += 32;
			continue;
		}
		return(0);

#ifdef	REGEXP_H_WCHARS
	case CCL|CMB:
	case CNCL|CMB:
		c = regexp_h_fetch(lp, 1);
		if (regexp_h_cclass(ep, c, (ep[-1] & 0377) == (CCL|CMB))) {
			ep += (*ep & 0377) + 17;
			continue;
		}
		return 0;
#endif	/* REGEXP_H_WCHARS */

	case CBRA:
		braslist[*ep++ & 0377] = (char *)lp;
		continue;

	case CKET:
		braelist[*ep++ & 0377] = (char *)lp;
		continue;

	case CBRC:
		if (lp == regexp_h_bol && locs == NULL)
			continue;
		if ((isdigit(lp[0] & 0377) || regexp_h_uletter(lp[0] & 0377))
				&& !regexp_h_uletter(lp[-1] & 0377)
				&& !isdigit(lp[-1] & 0377))
			continue;
		return(0);

#ifdef	REGEXP_H_WCHARS
	case CBRC|CMB:
		c = regexp_h_show(lp);
		d = regexp_h_previous(lp);
		if ((iswdigit(c) || regexp_h_wuletter(c))
				&& !regexp_h_wuletter(d)
				&& !iswdigit(d))
			continue;
		return(0);
#endif	/* REGEXP_H_WCHARS */

	case CLET:
		if (!regexp_h_uletter(lp[0] & 0377) && !isdigit(lp[0] & 0377))
			continue;
		return(0);

#ifdef	REGEXP_H_WCHARS
	case CLET|CMB:
		c = regexp_h_show(lp);
		if (!regexp_h_wuletter(c) && !iswdigit(c))
			continue;
		return(0);
#endif	/* REGEXP_H_WCHARS */

	case CCHR|RNGE:
		c = *ep++;
		regexp_h_getrnge(ep, least);
		while(low--)
			if(*lp++ != c)
				return(0);
		curlp = lp;
		while(size--) {
			regexp_h_push(&sb, &sp, &sc, lp);
			if(*lp++ != c)
				break;
		}
		if(size < 0) {
			regexp_h_push(&sb, &sp, &sc, lp);
			lp++;
		}
		ep += 2;
		goto star;

#ifdef	REGEXP_H_WCHARS
	case CCHR|RNGE|CMB:
	case CCH1|RNGE:
	case CCH2|RNGE:
	case CCH3|RNGE:
		c = regexp_h_fetch(ep, 0);
		regexp_h_getrnge(ep, least);
		while (low--)
			if (regexp_h_fetch(lp, 1) != c)
				return 0;
		curlp = lp;
		while (size--) {
			regexp_h_push(&sb, &sp, &sc, lp);
			if (regexp_h_fetch(lp, 1) != c)
				break;
		}
		if(size < 0) {
			regexp_h_push(&sb, &sp, &sc, lp);
			regexp_h_fetch(lp, 1);
		}
		ep += 2;
		goto star;
#endif	/* REGEXP_H_WCHARS */

	case CDOT|RNGE:
		regexp_h_getrnge(ep, least);
		while(low--)
			if(*lp++ == '\0')
				return(0);
		curlp = lp;
		while(size--) {
			regexp_h_push(&sb, &sp, &sc, lp);
			if(*lp++ == '\0')
				break;
		}
		if(size < 0) {
			regexp_h_push(&sb, &sp, &sc, lp);
			lp++;
		}
		ep += 2;
		goto star;

#ifdef	REGEXP_H_WCHARS
	case CDOT|RNGE|CMB:
		regexp_h_getrnge(ep, least);
		while (low--)
			if ((c = regexp_h_fetch(lp, 1)) == L'\0' || c == WEOF)
				return 0;
		curlp = lp;
		while (size--) {
			regexp_h_push(&sb, &sp, &sc, lp);
			if ((c = regexp_h_fetch(lp, 1)) == L'\0' || c == WEOF)
				break;
		}
		if (size < 0) {
			regexp_h_push(&sb, &sp, &sc, lp);
			regexp_h_fetch(lp, 1);
		}
		ep += 2;
		goto star;
#endif	/* REGEXP_H_WCHARS */

	case CCL|RNGE:
		regexp_h_getrnge(ep + 32, least);
		while(low--) {
			c = *lp++ & 0377;
			if(!ISTHERE(c))
				return(0);
		}
		curlp = lp;
		while(size--) {
			regexp_h_push(&sb, &sp, &sc, lp);
			c = *lp++ & 0377;
			if(!ISTHERE(c))
				break;
		}
		if(size < 0) {
			regexp_h_push(&sb, &sp, &sc, lp);
			lp++;
		}
		ep += 34;		/* 32 + 2 */
		goto star;

#ifdef	REGEXP_H_WCHARS
	case CCL|RNGE|CMB:
	case CNCL|RNGE|CMB:
		regexp_h_getrnge(ep + (*ep & 0377) + 17, least);
		while (low--) {
			c = regexp_h_fetch(lp, 1);
			if (!regexp_h_cclass(ep, c,
					(ep[-1] & 0377 & ~REGEXP_H_LEAST)
					== (CCL|RNGE|CMB)))
				return 0;
		}
		curlp = lp;
		while (size--) {
			regexp_h_push(&sb, &sp, &sc, lp);
			c = regexp_h_fetch(lp, 1);
			if (!regexp_h_cclass(ep, c,
					(ep[-1] & 0377 & ~REGEXP_H_LEAST)
					== (CCL|RNGE|CMB)))
				break;
		}
		if (size < 0) {
			regexp_h_push(&sb, &sp, &sc, lp);
			regexp_h_fetch(lp, 1);
		}
		ep += (*ep & 0377) + 19;
		goto star;
#endif	/* REGEXP_H_WCHARS */

	case CBACK:
		bbeg = braslist[*ep & 0377];
		ct = braelist[*ep++ & 0377] - bbeg;

		if(strncmp(bbeg, lp, ct) == 0) {
			lp += ct;
			continue;
		}
		return(0);

	case CBACK|STAR:
		bbeg = braslist[*ep & 0377];
		ct = braelist[*ep++ & 0377] - bbeg;
		curlp = lp;
		while(strncmp(bbeg, lp, ct) == 0)
			lp += ct;

		while(lp >= curlp) {
			if(regexp_h_advance(lp, ep))	return(1);
			lp -= ct;
		}
		return(0);


	case CDOT|STAR:
		curlp = lp;
		do
			regexp_h_push(&sb, &sp, &sc, lp);
		while (*lp++);
		goto star;

#ifdef	REGEXP_H_WCHARS
	case CDOT|STAR|CMB:
		curlp = lp;
		do
			regexp_h_push(&sb, &sp, &sc, lp);
		while ((c = regexp_h_fetch(lp, 1)) != L'\0' && c != WEOF);
		goto star;
#endif	/* REGEXP_H_WCHARS */

	case CCHR|STAR:
		curlp = lp;
		do
			regexp_h_push(&sb, &sp, &sc, lp);
		while (*lp++ == *ep);
		ep++;
		goto star;

#ifdef	REGEXP_H_WCHARS
	case CCHR|STAR|CMB:
	case CCH1|STAR:
	case CCH2|STAR:
	case CCH3|STAR:
		curlp = lp;
		d = regexp_h_fetch(ep, 0);
		do
			regexp_h_push(&sb, &sp, &sc, lp);
		while (regexp_h_fetch(lp, 1) == d);
		goto star;
#endif	/* REGEXP_H_WCHARS */

	case CCL|STAR:
		curlp = lp;
		do {
			regexp_h_push(&sb, &sp, &sc, lp);
			c = *lp++ & 0377;
		} while(ISTHERE(c));
		ep += 32;
		goto star;

#ifdef	REGEXP_H_WCHARS
	case CCL|STAR|CMB:
	case CNCL|STAR|CMB:
		curlp = lp;
		do {
			regexp_h_push(&sb, &sp, &sc, lp);
			c = regexp_h_fetch(lp, 1);
		} while (regexp_h_cclass(ep, c, (ep[-1] & 0377)
					== (CCL|STAR|CMB)));
		ep += (*ep & 0377) + 17;
		goto star;
#endif	/* REGEXP_H_WCHARS */

	star:
#ifdef	REGEXP_H_WCHARS
		if (regexp_h_wchars == 0) {
#endif
			do {
				if(--lp == locs)
					break;
				if (regexp_h_advance(lp, ep))
					return(1);
			} while (lp > curlp);
#ifdef	REGEXP_H_WCHARS
		} else {
			do {
				lp = regexp_h_pop(&sb, &sp, &sc, lp);
				if (lp <= locs)
					break;
				if (regexp_h_advance(lp, ep)) {
					regexp_h_zerostak(&sb, &sp);
					return(1);
				}
			} while (lp > curlp);
			regexp_h_zerostak(&sb, &sp);
		}
#endif	/* REGEXP_H_WCHARS */
		return(0);

	}
}

static void
regexp_h_getrnge(register const char *str, int least)
{
	low = *str++ & 0377;
	size = least & REGEXP_H_LEAST ? /*20000*/INT_MAX : (*str & 0377) - low;
}

int
advance(const char *lp, const char *ep)
{
	REGEXP_H_ADVANCE_INIT	/* skip past circf */
	regexp_h_bol = lp;
#ifdef	REGEXP_H_WCHARS
	regexp_h_firstwc = NULL;
#endif	/* REGEXP_H_WCHARS */
	return regexp_h_advance(lp, ep);
}