/*
 * This code contains changes by
 *      Gunnar Ritter, Freiburg i. Br., Germany, 2002. All rights reserved.
 *
 * Conditions 1, 2, and 4 and the no-warranty notice below apply
 * to these changes.
 *
 *
 * Copyright (c) 1980, 1993
 * 	The Regents of the University of California.  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.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 * 	This product includes software developed by the University of
 * 	California, Berkeley and its contributors.
 * 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.
 *
 *
 * 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.
 */

#ifndef	lint
#ifdef	DOSCCS
static char sccsid[] = "@(#)ex_re.c	1.56 (gritter) 3/25/05";
#endif
#endif

/* from ex_re.c	7.5 (Berkeley) 6/7/85 */

#include "ex.h"
#include "ex_re.h"

#ifdef	UXRE

#include <regex.h>

char	*braslist[NBRA];
char	*braelist[NBRA];
char	*loc1;
char	*loc2;

#else	/* !UXRE */
static int	regerrno;

#define	INIT			register char *sp = instring;
#define	GETC()			(*sp++)
#define	PEEKC()			(*sp)
#define	UNGETC(c)		(--sp)
#define	RETURN(c)		return(ep);
#define	ERROR(c)		{ regerrno = c; return 0; }

#define	compile(a, b, c, d)	_compile(a, b, c, d)
#define	regexp_h_static		static

#ifndef	NO_BE_BACKSLASH
#define	REGEXP_H_VI_BACKSLASH
#endif	/* !NO_BE_BACKSLASH */

#ifdef	MB
#define	REGEXP_H_WCHARS
#endif	/* MB */

#define	REGEXP_H_USED_FROM_VI

#include "regexp.h"

#ifndef	REG_ICASE
#define	REG_ICASE	1
#endif

static size_t
loconv(register char *dst, register const char *src)
{
	char	*odst = dst;

#ifdef	MB
	if (mb_cur_max > 1) {
		char	mb[MB_LEN_MAX];
		wchar_t wc;
		int len, i, nlen;

		for (;;) {
			if ((*src & 0200) == 0) {
				*dst++ = tolower(*src);
				if (*src++ == '\0')
					break;
			} else if ((len = mbtowc(&wc, src, mb_cur_max)) <= 0) {
				*dst++ = *src++;
			} else {
				wc = towlower(wc);
				if (len >= mb_cur_max) {
					if ((nlen = wctomb(dst, wc)) <= len) {
						dst += nlen;
						src += len;
					} else {
						*dst++ = *src++;
					}
				} else {
					if ((nlen = wctomb(mb, wc)) <= len) {
						src += len;
						for (i = 0; i < nlen; i++)
							*dst++ = mb[i];
					} else {
						*dst++ = *src++;
					}
				}
			}
		}
	} else
#endif	/* MB */
	{
		do
			*dst++ = tolower(*src & 0377);
		while (*src++);
	}
	return dst - odst;
}

#undef	compile

#endif	/* !UXRE */

/*
 * Global, substitute and regular expressions.
 * Very similar to ed, with some re extensions and
 * confirmed substitute.
 */
void 
global(int k)
{
	register char *gp;
	register int c, i;
	register line *a1;
	char	mb[MB_LEN_MAX+1];
	char globuf[GBSIZE], *Cwas;
	int lines = lineDOL();
	int oinglobal = inglobal;
	char *oglobp = globp;

	Cwas = Command;
	/*
	 * States of inglobal:
	 *  0: ordinary - not in a global command.
	 *  1: text coming from some buffer, not tty.
	 *  2: like 1, but the source of the buffer is a global command.
	 * Hence you're only in a global command if inglobal==2. This
	 * strange sounding convention is historically derived from
	 * everybody simulating a global command.
	 */
	if (inglobal==2)
		error(catgets(catd, 1, 121,
				"Global within global@not allowed"));
	markDOT();
	setall();
	nonzero();
	if (skipend())
		error(catgets(catd, 1, 122,
		"Global needs re|Missing regular expression for global"));
	c = GETWC(mb);
	ignore(compile(c, 1));
	savere(&scanre);
	gp = globuf;
	while ((c = GETWC(mb)) != '\n') {
		switch (c) {

		case EOF:
			c = '\n';
			goto brkwh;

		case '\\':
			c = GETWC(mb);
			switch (c) {

			case '\\':
				ungetchar(c);
				break;

			case '\n':
				break;

			default:
				*gp++ = '\\';
				break;
			}
			break;
		}
		for (i = 0; mb[i]; i++) {
			*gp++ = mb[i];
			if (gp >= &globuf[GBSIZE - 2])
				error(catgets(catd, 1, 123,
						"Global command too long"));
		}
	}
brkwh:
	ungetchar(c);
/* out: */
	newline();
	*gp++ = c;
	*gp++ = 0;
	saveall();
	inglobal = 2;
	for (a1 = one; a1 <= dol; a1++) {
		*a1 &= ~01;
		if (a1 >= addr1 && a1 <= addr2 && execute(0, a1) == k)
			*a1 |= 01;
	}
#ifdef notdef
/*
 * This code is commented out for now.  The problem is that we don't
 * fix up the undo area the way we should.  Basically, I think what has
 * to be done is to copy the undo area down (since we shrunk everything)
 * and move the various pointers into it down too.  I will do this later
 * when I have time. (Mark, 10-20-80)
 */
	/*
	 * Special case: g/.../d (avoid n^2 algorithm)
	 */
	if (globuf[0]=='d' && globuf[1]=='\n' && globuf[2]=='\0') {
		gdelete();
		return;
	}
#endif
	if (inopen)
		inopen = -1;
	/*
	 * Now for each marked line, set dot there and do the commands.
	 * Note the n^2 behavior here for lots of lines matching.
	 * This is really needed: in some cases you could delete lines,
	 * causing a marked line to be moved before a1 and missed if
	 * we didn't restart at zero each time.
	 */
	for (a1 = one; a1 <= dol; a1++) {
		if (*a1 & 01) {
			*a1 &= ~01;
			dot = a1;
			globp = globuf;
			commands(1, 1);
			a1 = zero;
		}
	}
	globp = oglobp;
	inglobal = oinglobal;
	endline = 1;
	Command = Cwas;
	netchHAD(lines);
	setlastchar(EOF);
	if (inopen) {
		ungetchar(EOF);
		inopen = 1;
	}
}

/*
 * gdelete: delete inside a global command. Handles the
 * special case g/r.e./d. All lines to be deleted have
 * already been marked. Squeeze the remaining lines together.
 * Note that other cases such as g/r.e./p, g/r.e./s/r.e.2/rhs/,
 * and g/r.e./.,/r.e.2/d are not treated specially.  There is no
 * good reason for this except the question: where to you draw the line?
 */
void 
gdelete(void)
{
	register line *a1, *a2, *a3;

	a3 = dol;
	/* find first marked line. can skip all before it */
	for (a1=zero; (*a1&01)==0; a1++)
		if (a1>=a3)
			return;
	/* copy down unmarked lines, compacting as we go. */
	for (a2=a1+1; a2<=a3;) {
		if (*a2&01) {
			a2++;		/* line is marked, skip it */
			dot = a1;	/* dot left after line deletion */
		} else
			*a1++ = *a2++;	/* unmarked, copy it */
	}
	dol = a1-1;
	if (dot>dol)
		dot = dol;
	change();
}

bool	cflag;
int	scount, slines, stotal;

int 
substitute(int c)
{
	register line *addr;
	register int n;
	int gsubf, hopcount;

	gsubf = compsub(c);
	if(FIXUNDO)
		save12(), undkind = UNDCHANGE;
	stotal = 0;
	slines = 0;
	for (addr = addr1; addr <= addr2; addr++) {
		scount = hopcount = 0;
		if (dosubcon(0, addr) == 0)
			continue;
		if (gsubf) {
			/*
			 * The loop can happen from s/\</&/g
			 * but we don't want to break other, reasonable cases.
			 */
			while (*loc2) {
				if (++hopcount > sizeof linebuf)
					error(catgets(catd, 1, 124,
							"substitution loop"));
				if (dosubcon(1, addr) == 0)
					break;
			}
		}
		if (scount) {
			stotal += scount;
			slines++;
			putmark(addr);
			n = append(getsub, addr);
			addr += n;
			addr2 += n;
		}
	}
	if (stotal == 0 && !inglobal && !cflag)
		error(catgets(catd, 1, 125,
				"Fail|Substitute pattern match failed"));
	snote(stotal, slines);
	return (stotal);
}

int 
compsub(int ch)
{
	register int seof, c, uselastre;
	char	mb[MB_LEN_MAX+1];
	static int gsubf;

	if (!value(EDCOMPATIBLE))
		gsubf = cflag = 0;
	uselastre = 0;
	switch (ch) {

	case 's':
		ignore(skipwh());
		seof = GETWC(mb);
		if (endcmd(seof) || any(seof, "gcr")) {
			ungetchar(seof);
			goto redo;
		}
		if (xisalnum(seof))
			error(catgets(catd, 1, 126,
	"Substitute needs re|Missing regular expression for substitute"));
		seof = compile(seof, 1);
		uselastre = 1;
		comprhs(seof);
		gsubf = 0;
		cflag = 0;
		break;

	case '~':
		uselastre = 1;
		/* fall into ... */
	case '&':
	redo:
		if (re.Patbuf[0] == 0)
			error(catgets(catd, 1, 127,
			"No previous re|No previous regular expression"));
		if (subre.Patbuf[0] == 0)
			error(catgets(catd, 1, 128,
	"No previous substitute re|No previous substitute to repeat"));
		break;
	}
	for (;;) {
		c = getchar();
		switch (c) {

		case 'g':
			gsubf = !gsubf;
			continue;

		case 'c':
			cflag = !cflag;
			continue;

		case 'r':
			uselastre = 1;
			continue;

		default:
			ungetchar(c);
			setcount();
			newline();
			if (uselastre)
				savere(&subre);
			else
				resre(&subre);
			return (gsubf);
		}
	}
}

void
comprhs(int seof)
{
	register char *rp, *orp;
	char	mb[MB_LEN_MAX+1];
#ifdef	BIT8
	char *qp, *oqp;
#endif
	register int c, i;
#ifdef	BIT8
	int q;
#endif
	char orhsbuf[RHSSIZE];
#ifdef	BIT8
	char orhsquo[RHSSIZE];
#endif
	int	hashflag = 0;

	rp = rhsbuf;
#ifdef	BIT8
	qp = rhsquo;
#endif
	CP(orhsbuf, rp);
#ifdef	BIT8
	copy(orhsquo, qp, (size_t) strlen(rp));
#endif
	for (;;) {
		c = GETWC(mb);
#ifdef	BIT8
		q = 0;
#endif
		if (c == seof)
			break;
		switch (c) {

		case '%':
			if (rp == rhsbuf)
				hashflag = 1;
			break;

		case '\\':
			c = GETWC(mb);
			if (c == EOF) {
				ungetchar(c);
				break;
			}
			if (value(MAGIC)) {
				/*
				 * When "magic", \& turns into a plain &,
				 * and all other chars work fine quoted.
				 */
				if (c != '&')
#ifndef	BIT8
					c |= QUOTE;
#else
					q = 1;
#endif
				break;
			}
magic:
			if (c == '~') {
hash:
#ifndef	BIT8
				for (orp = orhsbuf; *orp; *rp++ = *orp++) {
#else
				for (orp = orhsbuf, oqp = orhsquo;
						*orp; *rp++ = *orp++) {
					*qp++ = *oqp++;
#endif
					if (rp >= &rhsbuf[RHSSIZE - 1])
						goto toobig;
				}
				if (hashflag & 2)
					goto endrhs;
				continue;
			}
#ifndef	BIT8
			c |= QUOTE;
#else
			q = 1;
#endif
			break;

		case '\n':
		case EOF:
			if (!(globp && globp[0])) {
				ungetchar(c);
				goto endrhs;
			}

		case '~':
		case '&':
			if (value(MAGIC))
				goto magic;
			break;
		}
		if (rp >= &rhsbuf[RHSSIZE - 1]) {
toobig:
			*rp = 0;
			error(catgets(catd, 1, 129,
		"Replacement pattern too long@- limit 256 characters"));
		}
		for (i = 0; mb[i]; i++) {
			*rp++ = mb[i];
#ifdef	BIT8
			*qp++ = q;
#endif
		}
	}
endrhs:
	if (hashflag == 1 && rhsbuf[0] == '%' && rp == &rhsbuf[1]) {
		rp = rhsbuf;
		hashflag |= 2;
		goto hash;
	}
	*rp++ = 0;
}

int
getsub(void)
{
	register char *p;

	if ((p = linebp) == 0)
		return (EOF);
	strcLIN(p);
	linebp = 0;
	return (0);
}

int
dosubcon(bool f, line *a)
{

	if (execute(f, a) == 0)
		return (0);
	if (confirmed(a)) {
		dosub();
		scount++;
	}
	return (1);
}

int
confirmed(line *a)
{
	register int c;
	char *yesstr = catgets(catd, 1, 249, "y");
	int okay = -1;

	if (cflag == 0)
		return (1);
	pofix();
	pline(lineno(a));
	if (inopen)
		putchar('\n' | QUOTE);
	c = column(loc1 - 1);
	ugo(c - 1 + (inopen ? 1 : 0), ' ');
	ugo(column(loc2 - 1) - c, '^');
	flush();
	c = getkey();
again:
	if (c == '\r')
		c = '\n';
	if (inopen)
		putchar(c), flush();
	if (c != '\n' && c != EOF) {
		if (okay && *yesstr) {
			if (c == (*yesstr++ & 0377))
				okay = 1;
			else
				okay = 0;
		}
		c = getkey();
		goto again;
	}
	noteinp();
	return (okay > 0);
}

#ifdef	notdef
int
ex_getch(void)
{
	char c;

	if (read(2, &c, 1) != 1)
		return (EOF);
#ifndef	BIT8
	return (c & TRIM);
#else
	return c;
#endif
}
#endif	/* notdef */

void
ugo(int cnt, int with)
{

	if (cnt > 0)
		do
			putchar(with);
		while (--cnt > 0);
}

int	casecnt;
bool	destuc;

void
dosub(void)
{
	register char *lp, *sp, *rp;
	int c, n;
#ifdef	BIT8
	register char *qp;
	int q;
#endif

	lp = linebuf;
	sp = genbuf;
	rp = rhsbuf;
#ifdef	BIT8
	qp = rhsquo;
#endif
	while (lp < loc1)
		*sp++ = *lp++;
	casecnt = 0;
	while (*rp) {
		nextc(c, rp, n);
		rp += n;
#ifdef	BIT8
		c &= TRIM;
		q = *qp;
		qp += n;
#endif
		/* ^V <return> from vi to split lines */
		if (c == '\r')
			c = '\n';

#ifndef	BIT8
		if (c & QUOTE)
			switch (c & TRIM) {
#else
		if (q)
			switch (c) {
#endif

			case '&':
				sp = place(sp, loc1, loc2);
				if (sp == 0)
					goto ovflo;
				continue;

			case 'l':
				casecnt = 1;
				destuc = 0;
				continue;

			case 'L':
				casecnt = LBSIZE;
				destuc = 0;
				continue;

			case 'u':
				casecnt = 1;
				destuc = 1;
				continue;

			case 'U':
				casecnt = LBSIZE;
				destuc = 1;
				continue;

			case 'E':
			case 'e':
				casecnt = 0;
				continue;
			}
#ifndef	BIT8
		if (c < 0 && (c &= TRIM) >= '1' && c < re.Nbra + '1') {
#else
		if (q && c >= '1' && c < re.Nbra + '1') {
#endif
			sp = place(sp, braslist[c - '1'], braelist[c - '1']);
			if (sp == 0)
				goto ovflo;
			continue;
		}
#ifdef	MB
		if (mb_cur_max > 1) {
			char	mb[MB_LEN_MAX+1];
			int	i, m;
			if (casecnt)
				c = fixcase(c & TRIM);
			if (c & INVBIT || (m = wctomb(mb, c)) <= 0) {
				mb[0] = rp[-n];
				m = 1;
			}
			for (i = 0; i < m; i++) {
				*sp++ = mb[i];
				if (sp >= &genbuf[LBSIZE])
					goto ovflo;
			}
		} else
#endif	/* MB */
		{
			if (casecnt)
				*sp++ = fixcase(c & TRIM);
			else
				*sp++ = c & TRIM;
		}
		if (sp >= &genbuf[LBSIZE])
ovflo:
			error(catgets(catd, 1, 130,
					"Line overflow@in substitute"));
	}
	lp = loc2;
	loc2 = sp + (linebuf - genbuf);
#ifdef	UXRE
	if (loc1 == lp) {
		nextc(c, loc2, n);
		loc2 += n;
	}
#endif	/* UXRE */
	while (*sp++ = *lp++)
		if (sp >= &genbuf[LBSIZE])
			goto ovflo;
	strcLIN(genbuf);
}

int
fixcase(register int c)
{

	if (casecnt == 0)
		return (c);
	casecnt--;
#ifdef	MB
	if (c & INVBIT)
		return (c);
	if (mb_cur_max > 1) {
		if (destuc) {
			if (iswlower(c))
				c = towupper(c);
		} else
			if (iswupper(c))
				c = towlower(c);
	} else
#endif	/* MB */
	{
		if (destuc) {
			if (islower(c))
				c = toupper(c);
		} else
			if (isupper(c))
				c = tolower(c);
	}
	return (c);
}

char *
place(register char *sp, register char *l1, register char *l2)
{
	while (l1 < l2) {
#ifdef	MB
		if (mb_cur_max > 1) {
			char	mb[MB_LEN_MAX+1];
			int	c, i, m, n;

			nextc(c, l1, m);
			if (c & INVBIT) {
				m = n = 1;
				*mb = *l1;
			} else {
				c = fixcase(c);
				if ((n = wctomb(mb, c)) <= 0) {
					n = 1;
					*mb = *l1;
				}
			}
			l1 += m;
			for (i = 0; i < n; i++) {
				*sp++ = mb[i];
				if (sp >= &genbuf[LBSIZE])
					return (0);
			}
		} else
#endif	/* MB */
		{
			*sp++ = fixcase(*l1++);
			if (sp >= &genbuf[LBSIZE])
				return (0);
		}
	}
	return (sp);
}

void
snote(register int total, register int lines)
{

	if (!notable(total))
		return;
	printf(mesg(catgets(catd, 1, 131, "%d subs|%d substitutions")), total);
	if (lines != 1 && lines != total)
		printf(catgets(catd, 1, 132, " on %d lines"), lines);
	noonl();
	flush();
}

void
cerror(char *s)
{
	re.Patbuf[0] = '\0';
	error(s);
}

void
refree(struct regexp *rp)
{
	struct regexp *r1 = NULL, *r2 = NULL;
	
	if (rp->Expbuf == 0)
		return;
	if (rp == &re) {
		r1 = &scanre;
		r2 = &subre;
	} else if (rp == &scanre) {
		r1 = &re;
		r2 = &subre;
	} else if (rp == &subre) {
		r1 = &re;
		r2 = &scanre;
	}
	if ((r1->Expbuf == 0 || rp->Re_ident != r1->Re_ident) &&
			(r2->Expbuf == 0 || rp->Re_ident != r2->Re_ident)) {
#ifdef	UXRE
		regfree(rp->Expbuf);
#endif	/* UXRE */
		free(rp->Expbuf);
	}
	rp->Expbuf = 0;
}

struct regexp *
savere(struct regexp *store)
{
	refree(store);
	copy(store, &re, sizeof re);
	return store;
}

struct regexp *
resre(struct regexp *store)
{
	refree(&re);
	copy(&re, store, sizeof re);
	return store;
}

static void
compile1(void)
{
#ifdef	UXRE
	int	n;
#else	/* !UXRE */
	char	*r;
	char	*p;
#endif	/* !UXRE */

	refree(&re);
	re.Flags = value(IGNORECASE) ? REG_ICASE : 0;
#ifdef	UXRE
	re.Flags |= REG_ANGLES;
#ifndef	NO_BE_BACKSLASH
	re.Flags |= REG_BKTESCAPE | REG_BADRANGE;
#endif	/* !NO_BE_BACKSLASH */
	if (re.Expbuf == NULL)
		re.Expbuf = calloc(1, sizeof (regex_t));
	if ((n = regcomp(re.Expbuf, re.Patbuf, re.Flags)) != 0) {
		switch (n) {
		case REG_EBRACK:
			free(re.Expbuf);
			re.Expbuf = 0;
			cerror(catgets(catd, 1, 154, "Missing ]"));
			/*NOTREACHED*/
			break;
		default:
			regerror(n, re.Expbuf, &re.Patbuf[1],
					sizeof re.Patbuf - 1);
			free(re.Expbuf);
			re.Expbuf = 0;
			cerror(&re.Patbuf[1]);
		}
	}
	if ((re.Nbra = ((regex_t *)re.Expbuf)->re_nsub) > NBRA)
		re.Nbra = NBRA;
#else	/* !UXRE */
	if ((re.Expbuf = malloc(re.Length)) == NULL)
		cerror("Re too complex|Regular expression too complicated");
	if (re.Flags & REG_ICASE) {
		p = malloc(strlen(re.Patbuf) + 1);
		loconv(p, re.Patbuf);
	} else
		p = re.Patbuf;
	r = _compile(p, re.Expbuf, &((char *)re.Expbuf)[re.Length], '\0');
	if (p != re.Patbuf)
		free(p);
	if (r == 0) {
		char	*cp;
		free(re.Expbuf);
		re.Expbuf = 0;
		switch (regerrno) {
		case 11:
			cp = "Range endpoint too large|Range endpoint "
					"too large in regular expression";
			break;
		case 16:
			cp = "Bad number|Bad number in regular expression";
			break;
		case 25:
			cp = "\"\\digit\" out of range";
			break;
		case 36:
			cp = "Badly formed re|Missing closing delimiter "
				"for regular expression";
			break;
		case 42:
			cp = "\\( \\) Imbalance";
			break;
		case 43:
			cp = "Awash in \\('s!|Too many \\('d subexressions "
				"in a regular expression";
			break;
		case 44:
			cp = "More than 2 numbers given in \\{~\\}";
			break;
		case 45:
			cp = "} expected after \\";
			break;
		case 46:
			cp = "First number exceeds second in \\{~\\}";
			break;
		case 49:
			cp = "Missing ]";
			break;
		case 67:
			cp = "Illegal byte sequence|Regular expression "
				"has illegal byte sequence";
			break;
		default:
			cp = "Unknown regexp error code!!";
		}
		cerror(cp);
	}
	re.Circfl = circf;
	re.Nbra = nbra;
#endif	/* !UXRE */
	re.Re_ident++;
}

int
compile(int eof, int oknl)
{
	int c, d, i, n = 0;
	char	mb[MB_LEN_MAX+1];
	char *p = re.Patbuf, *end = re.Patbuf + sizeof re.Patbuf;
	int nomagic = value(MAGIC) ? 0 : 1, esc, rcnt = 0;
	char *rhsp;
#ifdef	BIT8
	char *rhsq;
#endif

	if (isalpha(eof) || isdigit(eof))
		error(catgets(catd, 1, 133,
	"Regular expressions cannot be delimited by letters or digits"));
	c = GETWC(mb);
	if (eof == '\\') {
		switch (c) {
		case '/':
		case '?':
			if (scanre.Patbuf[0] == 0)
				error(catgets(catd, 1, 134,
	"No previous scan re|No previous scanning regular expression"));
			resre(&scanre);
			return c;
		case '&':
			if (subre.Patbuf[0] == 0)
				error(catgets(catd, 1, 135,
	"No previous substitute re|No previous substitute regular expression"));
			resre(&subre);
			return c;
		default:
			error(catgets(catd, 1, 136,
	"Badly formed re|Regular expression \\ must be followed by / or ?"));
		}
	}
	if (c == eof || c == '\n' || c == EOF) {
		if (c == '\n' && oknl == 0)
			error(catgets(catd, 1, 138,
			"Missing closing delimiter@for regular expression"));
		if (c != eof)
			ungetchar(c);
		if (re.Expbuf == 0)
			error(catgets(catd, 1, 137,
			"No previous re|No previous regular expression"));
		return eof;
	}
	re.Nbra = re.Circfl = 0;
	if (c == '^')
		re.Circfl++;
	esc = 0;
	goto havec;
	/*
	 * Fetch the search pattern. This is quite a mess since we have
	 * to handle nomagic and ~.
	 */
	for (;;) {
		esc = 0;
		c = GETWC(mb);
	havec:	if (c == eof || c == EOF) {
			if (c == EOF)
				ungetchar(c);
			break;
		} else if (c == '\n') {
			if (!oknl)
				cerror(catgets(catd, 1, 157,
	"Badly formed re|Missing closing delimiter for regular expression"));
			ungetchar(c);
			break;
		} else if (nomagic) {
			switch (c) {
			case '.':
			case '*':
			case '[':
			case '~':
				*p++ = '\\';
				esc = 1;
				break;
			case '\\':
				c = GETWC(mb);
				if (c != '.' && c != '*' && c != '[' &&
						c != '~') {
					*p++ = '\\';
					esc = 1;
				}
			}
		} else if (c == '\\') {
			c = GETWC(mb);
			if (c != '~')
				*p++ = '\\';
			esc = 1;
		}
		if (c == EOF) {
			ungetchar(c);
			break;
		}
		if (!esc && c == '~') {
			rhsp = rhsbuf;
#ifdef	BIT8
			rhsq = rhsquo;
#endif
			while (*rhsp) {
#ifndef	BIT8
				if (*rhsp & QUOTE) {
					nextc(c, rhsp, n);
					c &= TRIM;
#else	/* BIT8 */
				if (*rhsq) {
					nextc(c, rhsp, n);
#endif	/* BIT8 */
					if (c == '&')
						error(catgets(catd, 1, 149,
			"Replacement pattern contains &@- cannot use in re"));
					if (c >= '1' && c <= '9')
						error(catgets(catd, 1, 150,
			"Replacement pattern contains \\d@- cannot use in re"));
				}
				if (p >= end - 3)
					goto complex;
				if (*rhsp == '\\' || *rhsp == '[' ||
						*rhsp == '.' ||
						*rhsp == '^' ||
						*rhsp == '*' ||
						*rhsp == '$')
					*p++ = '\\';
#ifdef	BIT8
				nextc(c, rhsp, n);
				for (i = 0; i < n; i++) {
					*p++ = *rhsp++;
					rhsq++;
				}
#else
				*p++ = *rhsp++ & TRIM;
#endif
			}
		} else if (!esc && c == '[') {
			rcnt++;
			/*
			 * Search for the end of the bracket expression
			 * since '~' may not be recognized inside.
			 */
			*p++ = (char)c;
			if (p >= end)
				goto complex;
			d = EOF;
			do {
				c = GETWC(mb);
				if (c == '\n' || c == EOF)
					cerror("Missing ]");
				for (i = 0; mb[i]; i++) {
					*p++ = mb[i];
					if (p >= end)
						goto complex;
				}
#ifdef	UXRE
				if (d == '[' && (c == ':' || c == '.' ||
							c == '=')) {
					d = c;
					do {
						c = GETWC(mb);
						if (c == '\n' || c == EOF)
							cerror("Missing ]");
						for (i = 0; mb[i]; i++) {
							*p++ = mb[i];
							if (p >= end)
								goto complex;
						}
					} while (c != d || peekchar() != ']');
					c = GETWC(mb);
					for (i = 0; mb[i]; i++) {
						*p++ = mb[i];
						if (p >= end)
							goto complex;
					}
					c = EOF; /* -> reset d and continue */
				}
#endif	/* UXRE */
				d = c;
			} while (c != ']');
		} else if (esc && c == '{') {
			/*
			 * Search for the end of the interval expression
			 * since '~' may not be recognized inside.
			 */
			for (i = 0; mb[i]; i++) {
				*p++ = mb[i];
				if (p >= end)
					goto complex;
			}
			do {
				c = GETWC(mb);
				if (c == '\n' || c == EOF)
					cerror(catgets(catd, 1, 143,
			"Bad number|Bad number in regular expression"));
				for (i = 0; mb[i]; i++) {
					*p++ = mb[i];
					if (p >= end)
						goto complex;
				}
			} while (c != '\\');
			c = GETWC(mb);
			if (c != '}')
				cerror(catgets(catd, 1, 146,
					"} expected after \\"));
			*p++ = (char)c;
		} else {
			for (i = 0; mb[i]; i++) {
				*p++ = mb[i];
				if (p >= end)
					goto complex;
			}
		}
		if (p >= end)
complex:		cerror(catgets(catd, 1, 139,
			"Re too complex|Regular expression too complicated"));
	}
	if (p == re.Patbuf)
		*p++ = '.';	/* approximate historical behavior */
	*p = '\0';
	re.Length = rcnt*32 + 2*(p-re.Patbuf) + 5;
	compile1();
	return eof;
}

#ifdef	UXRE
int
execute(int gf, line *addr)
{
	char *p;
	int c;
	int eflags = 0, nsub;
	regmatch_t bralist[NBRA + 1];

	if (gf) {
		if (re.Circfl)
			return 0;
		eflags |= REG_NOTBOL;
		p = loc2;
	} else {
		if (addr == zero)
			return 0;
		if ((value(IGNORECASE) ? 1:0) ^ (re.Flags & REG_ICASE ? 1:0))
			compile1();
		p = linebuf;
		getline(*addr);
	}
	/*
	 * Need subexpression matches only for substitute command,
	 * so don't fetch them otherwise (enables use of DFA).
	 */
	nsub = (re.Re_ident == subre.Re_ident ? NBRA : 0);
	switch (regexec(re.Expbuf, p, nsub + 1, bralist, eflags)) {
	case 0:
		break;
	case REG_NOMATCH:
		return 0;
	default:
		cerror(catgets(catd, 1, 139,
			"Re too complex|Regular expression too complicated"));
	}
	loc1 = p + bralist[0].rm_so;
	loc2 = p + bralist[0].rm_eo;
	for (c = 0; c < nsub; c++) {
		if (bralist[c + 1].rm_so != -1) {
			braslist[c] = p + bralist[c + 1].rm_so;
			braelist[c] = p + bralist[c + 1].rm_eo;
		} else
			braslist[c] = braelist[c] = NULL;
	}
	return 1;
}
#else	/* !UXRE */
int
execute(int gf, line *addr)
{
	char *p;

	if (gf) {
		if (re.Circfl)
			return 0;
		p = locs = loc2;
	} else {
		if (addr == zero)
			return 0;
		p = linebuf;
		getline(*addr);
		if ((value(IGNORECASE) ? 1:0) ^ (re.Flags & REG_ICASE ? 1:0))
			compile1();
		if (value(IGNORECASE))
			loconv(linebuf, linebuf);
		locs = 0;
	}
	circf = re.Circfl;
	return step(p, re.Expbuf);
}
#endif	/* !UXRE */