/*	$OpenBSD: misc.c,v 1.41 2015/09/10 22:48:58 nicm Exp $	*/

/*	$OpenBSD: path.c,v 1.13 2015/09/05 09:47:08 jsg Exp $	*/

/*-

 * Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,

 *		 2011, 2012, 2013, 2014, 2015, 2016, 2017

 *	mirabilos <m@mirbsd.org>

 * Copyright (c) 2015

 *	Daniel Richard G. <skunk@iSKUNK.ORG>

 *

 * Provided that these terms and disclaimer and all copyright notices

 * are retained or reproduced in an accompanying document, permission

 * is granted to deal in this work without restriction, including un-

 * limited rights to use, publicly perform, distribute, sell, modify,

 * merge, give away, or sublicence.

 *

 * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to

 * the utmost extent permitted by applicable law, neither express nor

 * implied; without malicious intent or gross negligence. In no event

 * may a licensor, author or contributor be held liable for indirect,

 * direct, other damage, loss, or other issues arising in any way out

 * of dealing in the work, even if advised of the possibility of such

 * damage or existence of a defect, except proven that it results out

 * of said person's immediate fault when using the work as intended.

 */

#include "sh.h"

#if !HAVE_GETRUSAGE

#include <sys/times.h>

#endif

#if HAVE_GRP_H

#include <grp.h>

#endif

__RCSID("$MirOS: src/bin/mksh/misc.c,v 1.291 2018/01/14 00:03:03 tg Exp $");

#define KSH_CHVT_FLAG

#ifdef MKSH_SMALL

#undef KSH_CHVT_FLAG

#endif

#ifdef TIOCSCTTY

#define KSH_CHVT_CODE

#define KSH_CHVT_FLAG

#endif

/* type bits for unsigned char */

unsigned char chtypes[UCHAR_MAX + 1];

static const unsigned char *pat_scan(const unsigned char *,

    const unsigned char *, bool) MKSH_A_PURE;

static int do_gmatch(const unsigned char *, const unsigned char *,

    const unsigned char *, const unsigned char *,

    const unsigned char *) MKSH_A_PURE;

static const unsigned char *gmatch_cclass(const unsigned char *, unsigned char)

    MKSH_A_PURE;

#ifdef KSH_CHVT_CODE

static void chvt(const Getopt *);

#endif

/*XXX this should go away */

static int make_path(const char *, const char *, char **, XString *, int *);

#ifdef SETUID_CAN_FAIL_WITH_EAGAIN

/* we don't need to check for other codes, EPERM won't happen */

#define DO_SETUID(func, argvec) do {					\

	if ((func argvec) && errno == EAGAIN)				\

		errorf("%s failed with EAGAIN, probably due to a"	\

		    " too low process limit; aborting", #func);		\

} while (/* CONSTCOND */ 0)

#else

#define DO_SETUID(func, argvec) func argvec

#endif

/* called from XcheckN() to grow buffer */

char *

Xcheck_grow(XString *xsp, const char *xp, size_t more)

{

	const char *old_beg = xsp->beg;

	if (more < xsp->len)

		more = xsp->len;

	/* (xsp->len + X_EXTRA) never overflows */

	checkoktoadd(more, xsp->len + X_EXTRA);

	xsp->beg = aresize(xsp->beg, (xsp->len += more) + X_EXTRA, xsp->areap);

	xsp->end = xsp->beg + xsp->len;

	return (xsp->beg + (xp - old_beg));

}

#define SHFLAGS_DEFNS

#define FN(sname,cname,flags,ochar)		\

	static const struct {			\

		/* character flag (if any) */	\

		char c;				\

		/* OF_* */			\

		unsigned char optflags;		\

		/* long name of option */	\

		char name[sizeof(sname)];	\

	} shoptione_ ## cname = {		\

		ochar, flags, sname		\

	};

#include "sh_flags.gen"

#define OFC(i) (options[i][-2])

#define OFF(i) (((const unsigned char *)options[i])[-1])

#define OFN(i) (options[i])

const char * const options[] = {

#define SHFLAGS_ITEMS

#include "sh_flags.gen"

};

/*

 * translate -o option into F* constant (also used for test -o option)

 */

size_t

option(const char *n)

{

	size_t i = 0;

	if (ctype(n[0], C_MINUS | C_PLUS) && n[1] && !n[2])

		while (i < NELEM(options)) {

			if (OFC(i) == n[1])

				return (i);

			++i;

		}

	else

		while (i < NELEM(options)) {

			if (!strcmp(OFN(i), n))

				return (i);

			++i;

		}

	return ((size_t)-1);

}

struct options_info {

	int opt_width;

	int opts[NELEM(options)];

};

static void options_fmt_entry(char *, size_t, unsigned int, const void *);

static void printoptions(bool);

/* format a single select menu item */

static void

options_fmt_entry(char *buf, size_t buflen, unsigned int i, const void *arg)

{

	const struct options_info *oi = (const struct options_info *)arg;

	shf_snprintf(buf, buflen, "%-*s %s",

	    oi->opt_width, OFN(oi->opts[i]),

	    Flag(oi->opts[i]) ? "on" : "off");

}

static void

printoptions(bool verbose)

{

	size_t i = 0;

	if (verbose) {

		size_t n = 0, len, octs = 0;

		struct options_info oi;

		struct columnise_opts co;

		/* verbose version */

		shf_puts("Current option settings\n", shl_stdout);

		oi.opt_width = 0;

		while (i < NELEM(options)) {

			if ((len = strlen(OFN(i)))) {

				oi.opts[n++] = i;

				if (len > octs)

					octs = len;

				len = utf_mbswidth(OFN(i));

				if ((int)len > oi.opt_width)

					oi.opt_width = (int)len;

			}

			++i;

		}

		co.shf = shl_stdout;

		co.linesep = '\n';

		co.prefcol = co.do_last = true;

		print_columns(&co, n, options_fmt_entry, &oi,

		    octs + 4, oi.opt_width + 4);

	} else {

		/* short version like AT&T ksh93 */

		shf_puts(Tset, shl_stdout);

		while (i < NELEM(options)) {

			if (Flag(i) && OFN(i)[0])

				shprintf(" -o %s", OFN(i));

			++i;

		}

		shf_putc('\n', shl_stdout);

	}

}

char *

getoptions(void)

{

	size_t i = 0;

	char c, m[(int)FNFLAGS + 1];

	char *cp = m;

	while (i < NELEM(options)) {

		if ((c = OFC(i)) && Flag(i))

			*cp++ = c;

		++i;

	}

	strndupx(cp, m, cp - m, ATEMP);

	return (cp);

}

/* change a Flag(*) value; takes care of special actions */

void

change_flag(enum sh_flag f, int what, bool newset)

{

	unsigned char oldval;

	unsigned char newval = (newset ? 1 : 0);

	if (f == FXTRACE) {

		change_xtrace(newval, true);

		return;

	}

	oldval = Flag(f);

	Flag(f) = newval = (newset ? 1 : 0);

#ifndef MKSH_UNEMPLOYED

	if (f == FMONITOR) {

		if (what != OF_CMDLINE && newval != oldval)

			j_change();

	} else

#endif

#ifndef MKSH_NO_CMDLINE_EDITING

	  if ((

#if !MKSH_S_NOVI

	    f == FVI ||

#endif

	    f == FEMACS || f == FGMACS) && newval) {

#if !MKSH_S_NOVI

		Flag(FVI) =

#endif

		    Flag(FEMACS) = Flag(FGMACS) = 0;

		Flag(f) = newval;

	} else

#endif

	  if (f == FPRIVILEGED && oldval && !newval) {

		/* Turning off -p? */

		/*XXX this can probably be optimised */

		kshegid = kshgid = getgid();

		ksheuid = kshuid = getuid();

#if HAVE_SETRESUGID

		DO_SETUID(setresgid, (kshegid, kshegid, kshegid));

#if HAVE_SETGROUPS

		/* setgroups doesn't EAGAIN on Linux */

		setgroups(1, &kshegid);

#endif

		DO_SETUID(setresuid, (ksheuid, ksheuid, ksheuid));

#else /* !HAVE_SETRESUGID */

		/* setgid, setegid, seteuid don't EAGAIN on Linux */

		setgid(kshegid);

#ifndef MKSH__NO_SETEUGID

		setegid(kshegid);

#endif

		DO_SETUID(setuid, (ksheuid));

#ifndef MKSH__NO_SETEUGID

		seteuid(ksheuid);

#endif

#endif /* !HAVE_SETRESUGID */

	} else if ((f == FPOSIX || f == FSH) && newval) {

		/* Turning on -o posix or -o sh? */

		Flag(FBRACEEXPAND) = 0;

		/* Turning on -o posix? */

		if (f == FPOSIX) {

			/* C locale required for compliance */

			UTFMODE = 0;

		}

	} else if (f == FTALKING) {

		/* Changing interactive flag? */

		if ((what == OF_CMDLINE || what == OF_SET) && procpid == kshpid)

			Flag(FTALKING_I) = newval;

	}

}

void

change_xtrace(unsigned char newval, bool dosnapshot)

{

	static bool in_xtrace;

	if (in_xtrace)

		return;

	if (!dosnapshot && newval == Flag(FXTRACE))

		return;

	if (Flag(FXTRACE) == 2) {

		shf_putc('\n', shl_xtrace);

		Flag(FXTRACE) = 1;

		shf_flush(shl_xtrace);

	}

	if (!dosnapshot && Flag(FXTRACE) == 1)

		switch (newval) {

		case 1:

			return;

		case 2:

			goto changed_xtrace;

		}

	shf_flush(shl_xtrace);

	if (shl_xtrace->fd != 2)

		close(shl_xtrace->fd);

	if (!newval || (shl_xtrace->fd = savefd(2)) == -1)

		shl_xtrace->fd = 2;

 changed_xtrace:

	if ((Flag(FXTRACE) = newval) == 2) {

		in_xtrace = true;

		Flag(FXTRACE) = 0;

		shf_puts(substitute(str_val(global("PS4")), 0), shl_xtrace);

		Flag(FXTRACE) = 2;

		in_xtrace = false;

	}

}

/*

 * Parse command line and set command arguments. Returns the index of

 * non-option arguments, -1 if there is an error.

 */

int

parse_args(const char **argv,

    /* OF_FIRSTTIME, OF_CMDLINE, or OF_SET */

    int what,

    bool *setargsp)

{

	static const char cmd_opts[] =

#define SHFLAGS_NOT_SET

#define SHFLAGS_OPTCS

#include "sh_flags.gen"

#undef SHFLAGS_NOT_SET

	    ;

	static const char set_opts[] =

#define SHFLAGS_NOT_CMD

#define SHFLAGS_OPTCS

#include "sh_flags.gen"

#undef SHFLAGS_NOT_CMD

	    ;

	bool set;

	const char *opts;

	const char *array = NULL;

	Getopt go;

	size_t i;

	int optc, arrayset = 0;

	bool sortargs = false;

	bool fcompatseen = false;

	if (what == OF_CMDLINE) {

		const char *p = argv[0], *q;

		/*

		 * Set FLOGIN before parsing options so user can clear

		 * flag using +l.

		 */

		if (*p != '-')

			for (q = p; *q; )

				if (mksh_cdirsep(*q++))

					p = q;

		Flag(FLOGIN) = (*p == '-');

		opts = cmd_opts;

	} else if (what == OF_FIRSTTIME) {

		opts = cmd_opts;

	} else

		opts = set_opts;

	ksh_getopt_reset(&go, GF_ERROR|GF_PLUSOPT);

	while ((optc = ksh_getopt(argv, &go, opts)) != -1) {

		set = tobool(!(go.info & GI_PLUS));

		switch (optc) {

		case 'A':

			if (what == OF_FIRSTTIME)

				break;

			arrayset = set ? 1 : -1;

			array = go.optarg;

			break;

		case 'o':

			if (what == OF_FIRSTTIME)

				break;

			if (go.optarg == NULL) {

				/*

				 * lone -o: print options

				 *

				 * Note that on the command line, -o requires

				 * an option (ie, can't get here if what is

				 * OF_CMDLINE).

				 */

				printoptions(set);

				break;

			}

			i = option(go.optarg);

			if ((i == FPOSIX || i == FSH) && set && !fcompatseen) {

				/*

				 * If running 'set -o posix' or

				 * 'set -o sh', turn off the other;

				 * if running 'set -o posix -o sh'

				 * allow both to be set though.

				 */

				Flag(FPOSIX) = 0;

				Flag(FSH) = 0;

				fcompatseen = true;

			}

			if ((i != (size_t)-1) && (set ? 1U : 0U) == Flag(i))

				/*

				 * Don't check the context if the flag

				 * isn't changing - makes "set -o interactive"

				 * work if you're already interactive. Needed

				 * if the output of "set +o" is to be used.

				 */

				;

			else if ((i != (size_t)-1) && (OFF(i) & what))

				change_flag((enum sh_flag)i, what, set);

			else {

				bi_errorf(Tf_sD_s, go.optarg,

				    Tunknown_option);

				return (-1);

			}

			break;

#ifdef KSH_CHVT_FLAG

		case 'T':

			if (what != OF_FIRSTTIME)

				break;

#ifndef KSH_CHVT_CODE

			errorf("no TIOCSCTTY ioctl");

#else

			change_flag(FTALKING, OF_CMDLINE, true);

			chvt(&go);

			break;

#endif

#endif

		case '?':

			return (-1);

		default:

			if (what == OF_FIRSTTIME)

				break;

			/* -s: sort positional params (AT&T ksh stupidity) */

			if (what == OF_SET && optc == 's') {

				sortargs = true;

				break;

			}

			for (i = 0; i < NELEM(options); i++)

				if (optc == OFC(i) &&

				    (what & OFF(i))) {

					change_flag((enum sh_flag)i, what, set);

					break;

				}

			if (i == NELEM(options))

				internal_errorf("parse_args: '%c'", optc);

		}

	}

	if (!(go.info & GI_MINUSMINUS) && argv[go.optind] &&

	    ctype(argv[go.optind][0], C_MINUS | C_PLUS) &&

	    argv[go.optind][1] == '\0') {

		/* lone - clears -v and -x flags */

		if (argv[go.optind][0] == '-') {

			Flag(FVERBOSE) = 0;

			change_xtrace(0, false);

		}

		/* set skips lone - or + option */

		go.optind++;

	}

	if (setargsp)

		/* -- means set $#/$* even if there are no arguments */

		*setargsp = !arrayset && ((go.info & GI_MINUSMINUS) ||

		    argv[go.optind]);

	if (arrayset) {

		const char *ccp = NULL;

		if (array && *array)

			ccp = skip_varname(array, false);

		if (!ccp || !(!ccp[0] || (ccp[0] == '+' && !ccp[1]))) {

			bi_errorf(Tf_sD_s, array, Tnot_ident);

			return (-1);

		}

	}

	if (sortargs) {

		for (i = go.optind; argv[i]; i++)

			;

		qsort(&argv[go.optind], i - go.optind, sizeof(void *),

		    ascpstrcmp);

	}

	if (arrayset)

		go.optind += set_array(array, tobool(arrayset > 0),

		    argv + go.optind);

	return (go.optind);

}

/* parse a decimal number: returns 0 if string isn't a number, 1 otherwise */

int

getn(const char *s, int *ai)

{

	char c;

	mksh_ari_u num;

	bool neg = false;

	num.u = 0;

	do {

		c = *s++;

	} while (ctype(c, C_SPACE));

	switch (c) {

	case '-':

		neg = true;

		/* FALLTHROUGH */

	case '+':

		c = *s++;

		break;

	}

	do {

		if (!ctype(c, C_DIGIT))

			/* not numeric */

			return (0);

		if (num.u > 214748364U)

			/* overflow on multiplication */

			return (0);

		num.u = num.u * 10U + (unsigned int)ksh_numdig(c);

		/* now: num.u <= 2147483649U */

	} while ((c = *s++));

	if (num.u > (neg ? 2147483648U : 2147483647U))

		/* overflow for signed 32-bit int */

		return (0);

	if (neg)

		num.u = -num.u;

	*ai = num.i;

	return (1);

}

/**

 * pattern simplifications:

 * - @(x) -> x (not @(x|y) though)

 * - ** -> *

 */

static void *

simplify_gmatch_pattern(const unsigned char *sp)

{

	uint8_t c;

	unsigned char *cp, *dp;

	const unsigned char *ps, *se;

	cp = alloc(strlen((const void *)sp) + 1, ATEMP);

	goto simplify_gmatch_pat1a;

	/* foo@(b@(a)r)b@(a|a)z -> foobarb@(a|a)z */

 simplify_gmatch_pat1:

	sp = cp;

 simplify_gmatch_pat1a:

	dp = cp;

	se = strnul(sp);

	while ((c = *sp++)) {

		if (!ISMAGIC(c)) {

			*dp++ = c;

			continue;

		}

		switch ((c = *sp++)) {

		case 0x80|'@':

		/* simile for @ */

		case 0x80|' ':

			/* check whether it has only one clause */

			ps = pat_scan(sp, se, true);

			if (!ps || ps[-1] != /*(*/ ')')

				/* nope */

				break;

			/* copy inner clause until matching close */

			ps -= 2;

			while ((const unsigned char *)sp < ps)

				*dp++ = *sp++;

			/* skip MAGIC and closing parenthesis */

			sp += 2;

			/* copy the rest of the pattern */

			memmove(dp, sp, strlen((const void *)sp) + 1);

			/* redo from start */

			goto simplify_gmatch_pat1;

		}

		*dp++ = MAGIC;

		*dp++ = c;

	}

	*dp = '\0';

	/* collapse adjacent asterisk wildcards */

	sp = dp = cp;

	while ((c = *sp++)) {

		if (!ISMAGIC(c)) {

			*dp++ = c;

			continue;

		}

		switch ((c = *sp++)) {

		case '*':

			while (ISMAGIC(sp[0]) && sp[1] == c)

				sp += 2;

			break;

		}

		*dp++ = MAGIC;

		*dp++ = c;

	}

	*dp = '\0';

	/* return the result, allocated from ATEMP */

	return (cp);

}

/* -------- gmatch.c -------- */

/*

 * int gmatch(string, pattern)

 * char *string, *pattern;

 *

 * Match a pattern as in sh(1).

 * pattern character are prefixed with MAGIC by expand.

 */

int

gmatchx(const char *s, const char *p, bool isfile)

{

	const char *se, *pe;

	char *pnew;

	int rv;

	if (s == NULL || p == NULL)

		return (0);

	pe = strnul(p);

	/*

	 * isfile is false iff no syntax check has been done on

	 * the pattern. If check fails, just do a strcmp().

	 */

	if (!isfile && !has_globbing(p)) {

		size_t len = pe - p + 1;

		char tbuf[64];

		char *t = len <= sizeof(tbuf) ? tbuf : alloc(len, ATEMP);

		debunk(t, p, len);

		return (!strcmp(t, s));

	}

	se = strnul(s);

	/*

	 * since the do_gmatch() engine sucks so much, we must do some

	 * pattern simplifications

	 */

	pnew = simplify_gmatch_pattern((const unsigned char *)p);

	pe = strnul(pnew);

	rv = do_gmatch((const unsigned char *)s, (const unsigned char *)se,

	    (const unsigned char *)pnew, (const unsigned char *)pe,

	    (const unsigned char *)s);

	afree(pnew, ATEMP);

	return (rv);

}

/**

 * Returns if p is a syntacticly correct globbing pattern, false

 * if it contains no pattern characters or if there is a syntax error.

 * Syntax errors are:

 *	- [ with no closing ]

 *	- imbalanced $(...) expression

 *	- [...] and *(...) not nested (eg, @(a[b|)c], *(a[b|c]d))

 */

/*XXX

 * - if no magic,

 *	if dest given, copy to dst

 *	return ?

 * - if magic && (no globbing || syntax error)

 *	debunk to dst

 *	return ?

 * - return ?

 */

bool

has_globbing(const char *pat)

{

	unsigned char c, subc;

	bool saw_glob = false;

	unsigned int nest = 0;

	const unsigned char *p = (const unsigned char *)pat;

	const unsigned char *s;

	while ((c = *p++)) {

		/* regular character? ok. */

		if (!ISMAGIC(c))

			continue;

		/* MAGIC + NUL? abort. */

		if (!(c = *p++))

			return (false);

		/* some specials */

		if (ord(c) == ORD('*') || ord(c) == ORD('?')) {

			/* easy glob, accept */

			saw_glob = true;

		} else if (ord(c) == ORD('[')) {

			/* bracket expression; eat negation and initial ] */

			if (ISMAGIC(p[0]) && ord(p[1]) == ORD('!'))

				p += 2;

			if (ISMAGIC(p[0]) && ord(p[1]) == ORD(']'))

				p += 2;

			/* check next string part */

			s = p;

			while ((c = *s++)) {

				/* regular chars are ok */

				if (!ISMAGIC(c))

					continue;

				/* MAGIC + NUL cannot happen */

				if (!(c = *s++))

					return (false);

				/* terminating bracket? */

				if (ord(c) == ORD(']')) {

					/* accept and continue */

					p = s;

					saw_glob = true;

					break;

				}

				/* sub-bracket expressions */

				if (ord(c) == ORD('[') && (

				    /* collating element? */

				    ord(*s) == ORD('.') ||

				    /* equivalence class? */

				    ord(*s) == ORD('=') ||

				    /* character class? */

				    ord(*s) == ORD(':'))) {

					/* must stop with exactly the same c */

					subc = *s++;

					/* arbitrarily many chars in betwixt */

					while ((c = *s++))

						/* but only this sequence... */

						if (c == subc && ISMAGIC(*s) &&

						    ord(s[1]) == ORD(']')) {

							/* accept, terminate */

							s += 2;

							break;

						}

					/* EOS without: reject bracket expr */

					if (!c)

						break;

					/* continue; */

				}

				/* anything else just goes on */

			}

		} else if ((c & 0x80) && ctype(c & 0x7F, C_PATMO | C_SPC)) {

			/* opening pattern */

			saw_glob = true;

			++nest;

		} else if (ord(c) == ORD(/*(*/ ')')) {

			/* closing pattern */

			if (nest)

				--nest;

		}

	}

	return (saw_glob && !nest);

}

/* Function must return either 0 or 1 (assumed by code for 0x80|'!') */

static int

do_gmatch(const unsigned char *s, const unsigned char *se,

    const unsigned char *p, const unsigned char *pe,

    const unsigned char *smin)

{

	unsigned char sc, pc, sl = 0;

	const unsigned char *prest, *psub, *pnext;

	const unsigned char *srest;

	if (s == NULL || p == NULL)

		return (0);

	if (s > smin && s <= se)

		sl = s[-1];

	while (p < pe) {

		pc = *p++;

		sc = s < se ? *s : '\0';

		s++;

		if (!ISMAGIC(pc)) {

			if (sc != pc)

				return (0);

			sl = sc;

			continue;

		}

		switch (ord(*p++)) {

		case ORD('['):

			/* BSD cclass extension? */

			if (ISMAGIC(p[0]) && ord(p[1]) == ORD('[') &&

			    ord(p[2]) == ORD(':') &&

			    ctype((pc = p[3]), C_ANGLE) &&

			    ord(p[4]) == ORD(':') &&

			    ISMAGIC(p[5]) && ord(p[6]) == ORD(']') &&

			    ISMAGIC(p[7]) && ord(p[8]) == ORD(']')) {

				/* zero-length match */

				--s;

				p += 9;

				/* word begin? */

				if (ord(pc) == ORD('<') &&

				    !ctype(sl, C_ALNUX) &&

				    ctype(sc, C_ALNUX))

					break;

				/* word end? */

				if (ord(pc) == ORD('>') &&

				    ctype(sl, C_ALNUX) &&

				    !ctype(sc, C_ALNUX))

					break;

				/* neither */

				return (0);

			}

			if (sc == 0 || (p = gmatch_cclass(p, sc)) == NULL)

				return (0);

			break;

		case ORD('?'):

			if (sc == 0)

				return (0);

			if (UTFMODE) {

				--s;

				s += utf_ptradj((const void *)s);

			}

			break;

		case ORD('*'):

			if (p == pe)

				return (1);

			s--;

			do {

				if (do_gmatch(s, se, p, pe, smin))

					return (1);

			} while (s++ < se);

			return (0);

		/**

		 * [+*?@!](pattern|pattern|..)

		 * This is also needed for ${..%..}, etc.

		 */

		/* matches one or more times */

		case ORD('+') | 0x80:

		/* matches zero or more times */

		case ORD('*') | 0x80:

			if (!(prest = pat_scan(p, pe, false)))

				return (0);

			s--;

			/* take care of zero matches */

			if (ord(p[-1]) == (0x80 | ORD('*')) &&

			    do_gmatch(s, se, prest, pe, smin))

				return (1);

			for (psub = p; ; psub = pnext) {

				pnext = pat_scan(psub, pe, true);

				for (srest = s; srest <= se; srest++) {

					if (do_gmatch(s, srest, psub, pnext - 2, smin) &&

					    (do_gmatch(srest, se, prest, pe, smin) ||

					    (s != srest &&

					    do_gmatch(srest, se, p - 2, pe, smin))))

						return (1);

				}

				if (pnext == prest)

					break;

			}

			return (0);

		/* matches zero or once */

		case ORD('?') | 0x80:

		/* matches one of the patterns */

		case ORD('@') | 0x80:

		/* simile for @ */

		case ORD(' ') | 0x80:

			if (!(prest = pat_scan(p, pe, false)))

				return (0);

			s--;

			/* Take care of zero matches */

			if (ord(p[-1]) == (0x80 | ORD('?')) &&

			    do_gmatch(s, se, prest, pe, smin))

				return (1);

			for (psub = p; ; psub = pnext) {

				pnext = pat_scan(psub, pe, true);

				srest = prest == pe ? se : s;