/*	$OpenBSD: eval.c,v 1.40 2013/09/14 20:09:30 millert Exp $	*/

/*-

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

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

 *	mirabilos <m@mirbsd.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"

__RCSID("$MirOS: src/bin/mksh/eval.c,v 1.219 2018/01/14 01:29:47 tg Exp $");

/*

 * string expansion

 *

 * first pass: quoting, IFS separation, ~, ${}, $() and $(()) substitution.

 * second pass: alternation ({,}), filename expansion (*?[]).

 */

/* expansion generator state */

typedef struct {

	/* not including an "int type;" member, see expand() */

	/* string */

	const char *str;

	/* source */

	union {

		/* string[] */

		const char **strv;

		/* file */

		struct shf *shf;

	} u;

	/* variable in ${var...} */

	struct tbl *var;

	/* split "$@" / call waitlast in $() */

	bool split;

} Expand;

#define	XBASE		0	/* scanning original */

#define	XSUB		1	/* expanding ${} string */

#define	XARGSEP		2	/* ifs0 between "$*" */

#define	XARG		3	/* expanding $*, $@ */

#define	XCOM		4	/* expanding $() */

#define XNULLSUB	5	/* "$@" when $# is 0 (don't generate word) */

#define XSUBMID		6	/* middle of expanding ${} */

/* States used for field splitting */

#define IFS_WORD	0	/* word has chars (or quotes except "$@") */

#define IFS_WS		1	/* have seen IFS white-space */

#define IFS_NWS		2	/* have seen IFS non-white-space */

#define IFS_IWS		3	/* beginning of word, ignore IFS WS */

#define IFS_QUOTE	4	/* beg.w/quote, become IFS_WORD unless "$@" */

#define STYPE_CHAR	0xFF

#define STYPE_DBL	0x100

#define STYPE_AT	0x200

#define STYPE_SINGLE	0x2FF

#define STYPE_MASK	0x300

static int varsub(Expand *, const char *, const char *, int *, int *);

static int comsub(Expand *, const char *, int);

static char *valsub(struct op *, Area *);

static char *trimsub(char *, char *, int);

static void glob(char *, XPtrV *, bool);

static void globit(XString *, char **, char *, XPtrV *, int);

static const char *maybe_expand_tilde(const char *, XString *, char **, bool);

#ifndef MKSH_NOPWNAM

static char *homedir(char *);

#endif

static void alt_expand(XPtrV *, char *, char *, char *, int);

static int utflen(const char *) MKSH_A_PURE;

static void utfincptr(const char *, mksh_ari_t *);

/* UTFMODE functions */

static int

utflen(const char *s)

{

	size_t n;

	if (UTFMODE) {

		n = 0;

		while (*s) {

			s += utf_ptradj(s);

			++n;

		}

	} else

		n = strlen(s);

	if (n > 2147483647)

		n = 2147483647;

	return ((int)n);

}

static void

utfincptr(const char *s, mksh_ari_t *lp)

{

	const char *cp = s;

	while ((*lp)--)

		cp += utf_ptradj(cp);

	*lp = cp - s;

}

/* compile and expand word */

char *

substitute(const char *cp, int f)

{

	struct source *s, *sold;

	sold = source;

	s = pushs(SWSTR, ATEMP);

	s->start = s->str = cp;

	source = s;

	if (yylex(ONEWORD) != LWORD)

		internal_errorf(Tbadsubst);

	source = sold;

	afree(s, ATEMP);

	return (evalstr(yylval.cp, f));

}

/*

 * expand arg-list

 */

char **

eval(const char **ap, int f)

{

	XPtrV w;

	if (*ap == NULL) {

		union mksh_ccphack vap;

		vap.ro = ap;

		return (vap.rw);

	}

	XPinit(w, 32);

	/* space for shell name */

	XPput(w, NULL);

	while (*ap != NULL)

		expand(*ap++, &w, f);

	XPput(w, NULL);

	return ((char **)XPclose(w) + 1);

}

/*

 * expand string

 */

char *

evalstr(const char *cp, int f)

{

	XPtrV w;

	char *dp = null;

	XPinit(w, 1);

	expand(cp, &w, f);

	if (XPsize(w))

		dp = *XPptrv(w);

	XPfree(w);

	return (dp);

}

/*

 * expand string - return only one component

 * used from iosetup to expand redirection files

 */

char *

evalonestr(const char *cp, int f)

{

	XPtrV w;

	char *rv;

	XPinit(w, 1);

	expand(cp, &w, f);

	switch (XPsize(w)) {

	case 0:

		rv = null;

		break;

	case 1:

		rv = (char *) *XPptrv(w);

		break;

	default:

		rv = evalstr(cp, f & ~DOGLOB);

		break;

	}

	XPfree(w);

	return (rv);

}

/* for nested substitution: ${var:=$var2} */

typedef struct SubType {

	struct tbl *var;	/* variable for ${var..} */

	struct SubType *prev;	/* old type */

	struct SubType *next;	/* poped type (to avoid re-allocating) */

	size_t	base;		/* start position of expanded word */

	short	stype;		/* [=+-?%#] action after expanded word */

	short	f;		/* saved value of f (DOPAT, etc) */

	uint8_t	quotep;		/* saved value of quote (for ${..[%#]..}) */

	uint8_t	quotew;		/* saved value of quote (for ${..[+-=]..}) */

} SubType;

void

expand(

    /* input word */

    const char *ccp,

    /* output words */

    XPtrV *wp,

    /* DO* flags */

    int f)

{

	int c = 0;

	/* expansion type */

	int type;

	/* quoted */

	int quote = 0;

	/* destination string and live pointer */

	XString ds;

	char *dp;

	/* source */

	const char *sp;

	/* second pass flags */

	int fdo;

	/* have word */

	int word;

	/* field splitting of parameter/command substitution */

	int doblank;

	/* expansion variables */

	Expand x = {

		NULL, { NULL }, NULL, 0

	};

	SubType st_head, *st;

	/* record number of trailing newlines in COMSUB */

	int newlines = 0;

	bool saw_eq, make_magic;

	unsigned int tilde_ok;

	size_t len;

	char *cp;

	if (ccp == NULL)

		internal_errorf("expand(NULL)");

	/* for alias, readonly, set, typeset commands */

	if ((f & DOVACHECK) && is_wdvarassign(ccp)) {

		f &= ~(DOVACHECK | DOBLANK | DOGLOB | DOTILDE);

		f |= DOASNTILDE | DOSCALAR;

	}

	if (Flag(FNOGLOB))

		f &= ~DOGLOB;

	if (Flag(FMARKDIRS))

		f |= DOMARKDIRS;

	if (Flag(FBRACEEXPAND) && (f & DOGLOB))

		f |= DOBRACE;

	/* init destination string */

	Xinit(ds, dp, 128, ATEMP);

	type = XBASE;

	sp = ccp;

	fdo = 0;

	saw_eq = false;

	/* must be 1/0 */

	tilde_ok = (f & (DOTILDE | DOASNTILDE)) ? 1 : 0;

	doblank = 0;

	make_magic = false;

	word = (f&DOBLANK) ? IFS_WS : IFS_WORD;

	/* clang doesn't know OSUBST comes before CSUBST */

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

	st = &st_head;

	while (/* CONSTCOND */ 1) {

		Xcheck(ds, dp);

		switch (type) {

		case XBASE:

			/* original prefixed string */

			c = ord(*sp++);

			switch (c) {

			case EOS:

				c = 0;

				break;

			case CHAR:

				c = ord(*sp++);

				break;

			case QCHAR:

				/* temporary quote */

				quote |= 2;

				c = ord(*sp++);

				break;

			case OQUOTE:

				if (word != IFS_WORD)

					word = IFS_QUOTE;

				tilde_ok = 0;

				quote = 1;

				continue;

			case CQUOTE:

				if (word == IFS_QUOTE)

					word = IFS_WORD;

				quote = st->quotew;

				continue;

			case COMASUB:

			case COMSUB:

			case FUNASUB:

			case FUNSUB:

			case VALSUB:

				tilde_ok = 0;

				if (f & DONTRUNCOMMAND) {

					word = IFS_WORD;

					*dp++ = '$';

					switch (c) {

					case COMASUB:

					case COMSUB:

						*dp++ = '(';

						c = ORD(')');

						break;

					case FUNASUB:

					case FUNSUB:

					case VALSUB:

						*dp++ = '{';

						*dp++ = c == VALSUB ? '|' : ' ';

						c = ORD('}');

						break;

					}

					while (*sp != '\0') {

						Xcheck(ds, dp);

						*dp++ = *sp++;

					}

					if ((unsigned int)c == ORD('}'))

						*dp++ = ';';

					*dp++ = c;

				} else {

					type = comsub(&x, sp, c);

					if (type != XBASE && (f & DOBLANK))

						doblank++;

					sp = strnul(sp) + 1;

					newlines = 0;

				}

				continue;

			case EXPRSUB:

				tilde_ok = 0;

				if (f & DONTRUNCOMMAND) {

					word = IFS_WORD;

					*dp++ = '$'; *dp++ = '('; *dp++ = '(';

					while (*sp != '\0') {

						Xcheck(ds, dp);

						*dp++ = *sp++;

					}

					*dp++ = ')'; *dp++ = ')';

				} else {

					struct tbl v;

					v.flag = DEFINED|ISSET|INTEGER;

					/* not default */

					v.type = 10;

					v.name[0] = '\0';

					v_evaluate(&v, substitute(sp, 0),

					    KSH_UNWIND_ERROR, true);

					sp = strnul(sp) + 1;

					x.str = str_val(&v);

					type = XSUB;

					if (f & DOBLANK)

						doblank++;

				}

				continue;

			case OSUBST: {

				/* ${{#}var{:}[=+-?#%]word} */

			/*-

			 * format is:

			 *	OSUBST [{x] plain-variable-part \0

			 *	    compiled-word-part CSUBST [}x]

			 * This is where all syntax checking gets done...

			 */

				/* skip the { or x (}) */

				const char *varname = ++sp;

				int stype;

				int slen = 0;

				/* skip variable */

				sp = cstrchr(sp, '\0') + 1;

				type = varsub(&x, varname, sp, &stype, &slen);

				if (type < 0) {

					char *beg, *end, *str;

 unwind_substsyn:

					/* restore sp */

					sp = varname - 2;

					beg = wdcopy(sp, ATEMP);

					end = (wdscan(cstrchr(sp, '\0') + 1,

					    CSUBST) - sp) + beg;

					/* ({) the } or x is already skipped */

					if (end < wdscan(beg, EOS))

						*end = EOS;

					str = snptreef(NULL, 64, Tf_S, beg);

					afree(beg, ATEMP);

					errorf(Tf_sD_s, str, Tbadsubst);

				}

				if (f & DOBLANK)

					doblank++;

				tilde_ok = 0;

				if (word == IFS_QUOTE && type != XNULLSUB)

					word = IFS_WORD;

				if (type == XBASE) {

					/* expand? */

					if (!st->next) {

						SubType *newst;

						newst = alloc(sizeof(SubType), ATEMP);

						newst->next = NULL;

						newst->prev = st;

						st->next = newst;

					}

					st = st->next;

					st->stype = stype;

					st->base = Xsavepos(ds, dp);

					st->f = f;

					if (x.var == vtemp) {

						st->var = tempvar(vtemp->name);

						st->var->flag &= ~INTEGER;

						/* can't fail here */

						setstr(st->var,

						    str_val(x.var),

						    KSH_RETURN_ERROR | 0x4);

					} else

						st->var = x.var;

					st->quotew = st->quotep = quote;

					/* skip qualifier(s) */

					if (stype)

						sp += slen;

					switch (stype & STYPE_SINGLE) {

					case ORD('#') | STYPE_AT:

						x.str = shf_smprintf("%08X",

						    (unsigned int)hash(str_val(st->var)));

						break;

					case ORD('Q') | STYPE_AT: {

						struct shf shf;

						shf_sopen(NULL, 0, SHF_WR|SHF_DYNAMIC, &shf;;

						print_value_quoted(&shf, str_val(st->var));

						x.str = shf_sclose(&shf;;

						break;

					    }

					case ORD('0'): {

						char *beg, *mid, *end, *stg;

						mksh_ari_t from = 0, num = -1, flen, finc = 0;

						beg = wdcopy(sp, ATEMP);

						mid = beg + (wdscan(sp, ADELIM) - sp);

						stg = beg + (wdscan(sp, CSUBST) - sp);

						mid[-2] = EOS;

						if (ord(mid[-1]) == ORD(/*{*/ '}')) {

							sp += mid - beg - 1;

							end = NULL;

						} else {

							end = mid +

							    (wdscan(mid, ADELIM) - mid);

							if (ord(end[-1]) != ORD(/*{*/ '}'))

								/* more than max delimiters */

								goto unwind_substsyn;

							end[-2] = EOS;

							sp += end - beg - 1;

						}

						evaluate(substitute(stg = wdstrip(beg, 0), 0),

						    &from, KSH_UNWIND_ERROR, true);

						afree(stg, ATEMP);

						if (end) {

							evaluate(substitute(stg = wdstrip(mid, 0), 0),

							    &num, KSH_UNWIND_ERROR, true);

							afree(stg, ATEMP);

						}

						afree(beg, ATEMP);

						beg = str_val(st->var);

						flen = utflen(beg);

						if (from < 0) {

							if (-from < flen)

								finc = flen + from;

						} else

							finc = from < flen ? from : flen;

						if (UTFMODE)

							utfincptr(beg, &finc);

						beg += finc;

						flen = utflen(beg);

						if (num < 0 || num > flen)

							num = flen;

						if (UTFMODE)

							utfincptr(beg, &num);

						strndupx(x.str, beg, num, ATEMP);

						goto do_CSUBST;

					    }

					case ORD('/') | STYPE_AT:

					case ORD('/'): {

						char *s, *p, *d, *sbeg, *end;

						char *pat = NULL, *rrep = null;

						char fpat = 0, *tpat1, *tpat2;

						char *ws, *wpat, *wrep;

						s = ws = wdcopy(sp, ATEMP);

						p = s + (wdscan(sp, ADELIM) - sp);

						d = s + (wdscan(sp, CSUBST) - sp);

						p[-2] = EOS;

						if (ord(p[-1]) == ORD(/*{*/ '}'))

							d = NULL;

						else

							d[-2] = EOS;

						sp += (d ? d : p) - s - 1;

						if (!(stype & STYPE_MASK) &&

						    s[0] == CHAR &&

						    ctype(s[1], C_SUB2))

							fpat = s[1];

						wpat = s + (fpat ? 2 : 0);

						wrep = d ? p : NULL;

						if (!(stype & STYPE_AT)) {

							rrep = wrep ? evalstr(wrep,

							    DOTILDE | DOSCALAR) :

							    null;

						}

						/* prepare string on which to work */

						strdupx(s, str_val(st->var), ATEMP);

						sbeg = s;

 again_search:

						pat = evalstr(wpat,

						    DOTILDE | DOSCALAR | DOPAT);

						/* check for special cases */

						if (!*pat && !fpat) {

							/*

							 * empty unanchored

							 * pattern => reject

							 */

							goto no_repl;

						}

						if ((stype & STYPE_MASK) &&

						    gmatchx(null, pat, false)) {

							/*

							 * pattern matches empty

							 * string => don't loop

							 */

							stype &= ~STYPE_MASK;

						}

						/* first see if we have any match at all */

						if (ord(fpat) == ORD('#')) {

							/* anchor at the beginning */

							tpat1 = shf_smprintf("%s%c*", pat, MAGIC);

							tpat2 = tpat1;

						} else if (ord(fpat) == ORD('%')) {

							/* anchor at the end */

							tpat1 = shf_smprintf("%c*%s", MAGIC, pat);

							tpat2 = pat;

						} else {

							/* float */

							tpat1 = shf_smprintf("%c*%s%c*", MAGIC, pat, MAGIC);

							tpat2 = tpat1 + 2;

						}

 again_repl:

						/*

						 * this would not be necessary if gmatchx would return

						 * the start and end values of a match found, like re*

						 */

						if (!gmatchx(sbeg, tpat1, false))

							goto end_repl;

						end = strnul(s);

						/* now anchor the beginning of the match */

						if (ord(fpat) != ORD('#'))

							while (sbeg <= end) {

								if (gmatchx(sbeg, tpat2, false))

									break;

								else

									sbeg++;

							}

						/* now anchor the end of the match */

						p = end;

						if (ord(fpat) != ORD('%'))

							while (p >= sbeg) {

								bool gotmatch;

								c = ord(*p);

								*p = '\0';

								gotmatch = tobool(gmatchx(sbeg, pat, false));

								*p = c;

								if (gotmatch)

									break;

								p--;

							}

						strndupx(end, sbeg, p - sbeg, ATEMP);

						record_match(end);

						afree(end, ATEMP);

						if (stype & STYPE_AT) {

							if (rrep != null)

								afree(rrep, ATEMP);

							rrep = wrep ? evalstr(wrep,

							    DOTILDE | DOSCALAR) :

							    null;

						}

						strndupx(end, s, sbeg - s, ATEMP);

						d = shf_smprintf(Tf_sss, end, rrep, p);

						afree(end, ATEMP);

						sbeg = d + (sbeg - s) + strlen(rrep);

						afree(s, ATEMP);

						s = d;

						if (stype & STYPE_AT) {

							afree(tpat1, ATEMP);

							afree(pat, ATEMP);

							goto again_search;

						} else if (stype & STYPE_DBL)

							goto again_repl;

 end_repl:

						afree(tpat1, ATEMP);

						x.str = s;

 no_repl:

						afree(pat, ATEMP);

						if (rrep != null)

							afree(rrep, ATEMP);

						afree(ws, ATEMP);

						goto do_CSUBST;

					    }

					case ORD('#'):

					case ORD('%'):

						/* ! DOBLANK,DOBRACE */

						f = (f & DONTRUNCOMMAND) |

						    DOPAT | DOTILDE |

						    DOTEMP | DOSCALAR;

						tilde_ok = 1;

						st->quotew = quote = 0;

						/*

						 * Prepend open pattern (so |

						 * in a trim will work as

						 * expected)

						 */

						if (!Flag(FSH)) {

							*dp++ = MAGIC;

							*dp++ = ORD(0x80 | '@');

						}

						break;

					case ORD('='):

						/*

						 * Tilde expansion for string

						 * variables in POSIX mode is

						 * governed by Austinbug 351.

						 * In non-POSIX mode historic

						 * ksh behaviour (enable it!)

						 * us followed.

						 * Not doing tilde expansion

						 * for integer variables is a

						 * non-POSIX thing - makes

						 * sense though, since ~ is

						 * a arithmetic operator.

						 */

						if (!(x.var->flag & INTEGER))

							f |= DOASNTILDE | DOTILDE;

						f |= DOTEMP | DOSCALAR;

						/*

						 * These will be done after the

						 * value has been assigned.

						 */

						f &= ~(DOBLANK|DOGLOB|DOBRACE);

						tilde_ok = 1;

						break;

					case ORD('?'):

						if (*sp == CSUBST)

							errorf("%s: parameter null or not set",

							    st->var->name);

						f &= ~DOBLANK;

						f |= DOTEMP;

						/* FALLTHROUGH */

					default:

						/* '-' '+' '?' */

						if (quote)

							word = IFS_WORD;

						else if (dp == Xstring(ds, dp))

							word = IFS_IWS;

						/* Enable tilde expansion */

						tilde_ok = 1;

						f |= DOTILDE;

					}

				} else

					/* skip word */

					sp += wdscan(sp, CSUBST) - sp;

				continue;

			    }

			case CSUBST:

				/* only get here if expanding word */

 do_CSUBST:

				/* ({) skip the } or x */

				sp++;

				/* in case of ${unset:-} */

				tilde_ok = 0;

				*dp = '\0';

				quote = st->quotep;

				f = st->f;

				if (f & DOBLANK)

					doblank--;

				switch (st->stype & STYPE_SINGLE) {

				case ORD('#'):

				case ORD('%'):

					if (!Flag(FSH)) {

						/* Append end-pattern */

						*dp++ = MAGIC;

						*dp++ = ')';

					}

					*dp = '\0';

					dp = Xrestpos(ds, dp, st->base);

					/*

					 * Must use st->var since calling

					 * global would break things

					 * like x[i+=1].

					 */

					x.str = trimsub(str_val(st->var),

						dp, st->stype);

					if (x.str[0] != '\0') {

						word = IFS_IWS;

						type = XSUB;

					} else if (quote) {

						word = IFS_WORD;

						type = XSUB;

					} else {

						if (dp == Xstring(ds, dp))

							word = IFS_IWS;

						type = XNULLSUB;

					}

					if (f & DOBLANK)

						doblank++;

					st = st->prev;

					continue;

				case ORD('='):

					/*

					 * Restore our position and substitute

					 * the value of st->var (may not be

					 * the assigned value in the presence

					 * of integer/right-adj/etc attributes).

					 */

					dp = Xrestpos(ds, dp, st->base);

					/*

					 * Must use st->var since calling

					 * global would cause with things

					 * like x[i+=1] to be evaluated twice.

					 */

					/*

					 * Note: not exported by FEXPORT

					 * in AT&T ksh.

					 */

					/*

					 * XXX POSIX says readonly is only

					 * fatal for special builtins (setstr

					 * does readonly check).

					 */

					len = strlen(dp) + 1;

					setstr(st->var,

					    debunk(alloc(len, ATEMP),

					    dp, len), KSH_UNWIND_ERROR);

					x.str = str_val(st->var);

					type = XSUB;

					if (f & DOBLANK)

						doblank++;

					st = st->prev;

					word = quote || (!*x.str && (f & DOSCALAR)) ? IFS_WORD : IFS_IWS;

					continue;

				case ORD('?'):

					dp = Xrestpos(ds, dp, st->base);

					errorf(Tf_sD_s, st->var->name,

					    debunk(dp, dp, strlen(dp) + 1));

					break;

				case ORD('0'):

				case ORD('/') | STYPE_AT:

				case ORD('/'):

				case ORD('#') | STYPE_AT:

				case ORD('Q') | STYPE_AT:

					dp = Xrestpos(ds, dp, st->base);

					type = XSUB;

					word = quote || (!*x.str && (f & DOSCALAR)) ? IFS_WORD : IFS_IWS;

					if (f & DOBLANK)

						doblank++;

					st = st->prev;

					continue;

				/* default: '-' '+' */

				}

				st = st->prev;

				type = XBASE;

				continue;

			case OPAT:

				/* open pattern: *(foo|bar) */

				/* Next char is the type of pattern */

				make_magic = true;

				c = ord(*sp++) | 0x80U;

				break;

			case SPAT:

				/* pattern separator (|) */

				make_magic = true;

				c = ORD('|');

				break;

			case CPAT:

				/* close pattern */

				make_magic = true;

				c = ORD(/*(*/ ')');

				break;

			}

			break;

		case XNULLSUB:

			/*

			 * Special case for "$@" (and "${foo[@]}") - no

			 * word is generated if $# is 0 (unless there is

			 * other stuff inside the quotes).

			 */

			type = XBASE;

			if (f & DOBLANK) {

				doblank--;

				if (dp == Xstring(ds, dp) && word != IFS_WORD)

					word = IFS_IWS;

			}

			continue;

		case XSUB:

		case XSUBMID:

			if ((c = ord(*x.str++)) == 0) {

				type = XBASE;

				if (f & DOBLANK)

					doblank--;

				continue;

			}

			break;

		case XARGSEP:

			type = XARG;

			quote = 1;

			/* FALLTHROUGH */

		case XARG:

			if ((c = ord(*x.str++)) == '\0') {

				/*

				 * force null words to be created so

				 * set -- "" 2 ""; echo "$@" will do

				 * the right thing

				 */

				if (quote && x.split)

					word = IFS_WORD;

				if ((x.str = *x.u.strv++) == NULL) {

					type = XBASE;

					if (f & DOBLANK)

						doblank--;

					continue;

				}

				c = ord(ifs0);

				if ((f & DOHEREDOC)) {

					/* pseudo-field-split reliably */

					if (c == 0)

						c = ORD(' ');

					break;

				}

				if ((f & DOSCALAR)) {

					/* do not field-split */

					if (x.split) {

						c = ORD(' ');

						break;

					}

					if (c == 0)

						continue;

				}

				if (c == 0) {

					if (quote && !x.split)

						continue;

					if (!quote && word == IFS_WS)

						continue;

					/* this is so we don't terminate */

					c = ORD(' ');

					/* now force-emit a word */

					goto emit_word;

				}

				if (quote && x.split) {