/*	$OpenBSD: lex.c,v 1.51 2015/09/10 22:48:58 nicm 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/lex.c,v 1.247 2018/01/14 01:44:01 tg Exp $");

/*

 * states while lexing word

 */

#define SBASE		0	/* outside any lexical constructs */

#define SWORD		1	/* implicit quoting for substitute() */

#define SLETPAREN	2	/* inside (( )), implicit quoting */

#define SSQUOTE		3	/* inside '' */

#define SDQUOTE		4	/* inside "" */

#define SEQUOTE		5	/* inside $'' */

#define SBRACE		6	/* inside ${} */

#define SQBRACE		7	/* inside "${}" */

#define SBQUOTE		8	/* inside `` */

#define SASPAREN	9	/* inside $(( )) */

#define SHEREDELIM	10	/* parsing << or <<- delimiter */

#define SHEREDQUOTE	11	/* parsing " in << or <<- delimiter */

#define SPATTERN	12	/* parsing *(...|...) pattern (*+?@!) */

#define SADELIM		13	/* like SBASE, looking for delimiter */

#define STBRACEKORN	14	/* parsing ${...[#%]...} !FSH */

#define STBRACEBOURNE	15	/* parsing ${...[#%]...} FSH */

#define SINVALID	255	/* invalid state */

struct sretrace_info {

	struct sretrace_info *next;

	XString xs;

	char *xp;

};

/*

 * Structure to keep track of the lexing state and the various pieces of info

 * needed for each particular state.

 */

typedef struct lex_state {

	union {

		/* point to the next state block */

		struct lex_state *base;

		/* marks start of state output in output string */

		size_t start;

		/* SBQUOTE: true if in double quotes: "`...`" */

		/* SEQUOTE: got NUL, ignore rest of string */

		bool abool;

		/* SADELIM information */

		struct {

			/* character to search for */

			unsigned char delimiter;

			/* max. number of delimiters */

			unsigned char num;

		} adelim;

	} u;

	/* count open parentheses */

	short nparen;

	/* type of this state */

	uint8_t type;

} Lex_state;

#define ls_base		u.base

#define ls_start	u.start

#define ls_bool		u.abool

#define ls_adelim	u.adelim

typedef struct {

	Lex_state *base;

	Lex_state *end;

} State_info;

static void readhere(struct ioword *);

static void ungetsc(int);

static void ungetsc_i(int);

static int getsc_uu(void);

static void getsc_line(Source *);

static int getsc_bn(void);

static int getsc_i(void);

static char *get_brace_var(XString *, char *);

static bool arraysub(char **);

static void gethere(void);

static Lex_state *push_state_i(State_info *, Lex_state *);

static Lex_state *pop_state_i(State_info *, Lex_state *);

static int backslash_skip;

static int ignore_backslash_newline;

/* optimised getsc_bn() */

#define o_getsc()	(*source->str != '\0' && *source->str != '\\' && \

			    !backslash_skip ? *source->str++ : getsc_bn())

/* optimised getsc_uu() */

#define	o_getsc_u()	((*source->str != '\0') ? *source->str++ : getsc_uu())

/* retrace helper */

#define o_getsc_r(carg)					\

	int cev = (carg);				\

	struct sretrace_info *rp = retrace_info;	\

							\

	while (rp) {					\

		Xcheck(rp->xs, rp->xp);			\

		*rp->xp++ = cev;			\

		rp = rp->next;				\

	}						\

							\

	return (cev);

/* callback */

static int

getsc_i(void)

{

	o_getsc_r((unsigned int)(unsigned char)o_getsc());

}

#if defined(MKSH_SMALL) && !defined(MKSH_SMALL_BUT_FAST)

#define getsc()		getsc_i()

#else

static int getsc_r(int);

static int

getsc_r(int c)

{

	o_getsc_r(c);

}

#define getsc()		getsc_r((unsigned int)(unsigned char)o_getsc())

#endif

#define STATE_BSIZE	8

#define PUSH_STATE(s)	do {					\

	if (++statep == state_info.end)				\

		statep = push_state_i(&state_info, statep);	\

	state = statep->type = (s);				\

} while (/* CONSTCOND */ 0)

#define POP_STATE()	do {					\

	if (--statep == state_info.base)			\

		statep = pop_state_i(&state_info, statep);	\

	state = statep->type;					\

} while (/* CONSTCOND */ 0)

#define PUSH_SRETRACE(s) do {					\

	struct sretrace_info *ri;				\

								\

	PUSH_STATE(s);						\

	statep->ls_start = Xsavepos(ws, wp);			\

	ri = alloc(sizeof(struct sretrace_info), ATEMP);	\

	Xinit(ri->xs, ri->xp, 64, ATEMP);			\

	ri->next = retrace_info;				\

	retrace_info = ri;					\

} while (/* CONSTCOND */ 0)

#define POP_SRETRACE()	do {					\

	wp = Xrestpos(ws, wp, statep->ls_start);		\

	*retrace_info->xp = '\0';				\

	sp = Xstring(retrace_info->xs, retrace_info->xp);	\

	dp = (void *)retrace_info;				\

	retrace_info = retrace_info->next;			\

	afree(dp, ATEMP);					\

	POP_STATE();						\

} while (/* CONSTCOND */ 0)

/**

 * Lexical analyser

 *

 * tokens are not regular expressions, they are LL(1).

 * for example, "${var:-${PWD}}", and "$(size $(whence ksh))".

 * hence the state stack. Note "$(...)" are now parsed recursively.

 */

int

yylex(int cf)

{

	Lex_state states[STATE_BSIZE], *statep, *s2, *base;

	State_info state_info;

	int c, c2, state;

	size_t cz;

	XString ws;		/* expandable output word */

	char *wp;		/* output word pointer */

	char *sp, *dp;

 Again:

	states[0].type = SINVALID;

	states[0].ls_base = NULL;

	statep = &states[1];

	state_info.base = states;

	state_info.end = &state_info.base[STATE_BSIZE];

	Xinit(ws, wp, 64, ATEMP);

	backslash_skip = 0;

	ignore_backslash_newline = 0;

	if (cf & ONEWORD)

		state = SWORD;

	else if (cf & LETEXPR) {

		/* enclose arguments in (double) quotes */

		*wp++ = OQUOTE;

		state = SLETPAREN;

		statep->nparen = 0;

	} else {

		/* normal lexing */

		state = (cf & HEREDELIM) ? SHEREDELIM : SBASE;

		do {

			c = getsc();

		} while (ctype(c, C_BLANK));

		if (c == '#') {

			ignore_backslash_newline++;

			do {

				c = getsc();

			} while (!ctype(c, C_NUL | C_LF));

			ignore_backslash_newline--;

		}

		ungetsc(c);

	}

	if (source->flags & SF_ALIAS) {

		/* trailing ' ' in alias definition */

		source->flags &= ~SF_ALIAS;

		/* POSIX: trailing space only counts if parsing simple cmd */

		if (!Flag(FPOSIX) || (cf & CMDWORD))

			cf |= ALIAS;

	}

	/* Initial state: one of SWORD SLETPAREN SHEREDELIM SBASE */

	statep->type = state;

	/* collect non-special or quoted characters to form word */

	while (!((c = getsc()) == 0 ||

	    ((state == SBASE || state == SHEREDELIM) && ctype(c, C_LEX1)))) {

		if (state == SBASE &&

		    subshell_nesting_type == ORD(/*{*/ '}') &&

		    (unsigned int)c == ORD(/*{*/ '}'))

			/* possibly end ${ :;} */

			break;

		Xcheck(ws, wp);

		switch (state) {

		case SADELIM:

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

				statep->nparen++;

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

				statep->nparen--;

			else if (statep->nparen == 0 &&

			    ((unsigned int)c == ORD(/*{*/ '}') ||

			    c == (int)statep->ls_adelim.delimiter)) {

				*wp++ = ADELIM;

				*wp++ = c;

				if ((unsigned int)c == ORD(/*{*/ '}') ||

				    --statep->ls_adelim.num == 0)

					POP_STATE();

				if ((unsigned int)c == ORD(/*{*/ '}'))

					POP_STATE();

				break;

			}

			/* FALLTHROUGH */

		case SBASE:

			if ((unsigned int)c == ORD('[') && (cf & CMDASN)) {

				/* temporary */

				*wp = EOS;

				if (is_wdvarname(Xstring(ws, wp), false)) {

					char *p, *tmp;

					if (arraysub(&tmp)) {

						*wp++ = CHAR;

						*wp++ = c;

						for (p = tmp; *p; ) {

							Xcheck(ws, wp);

							*wp++ = CHAR;

							*wp++ = *p++;

						}

						afree(tmp, ATEMP);

						break;

					}

				}

				*wp++ = CHAR;

				*wp++ = c;

				break;

			}

			/* FALLTHROUGH */

 Sbase1:		/* includes *(...|...) pattern (*+?@!) */

			if (ctype(c, C_PATMO)) {

				c2 = getsc();

				if ((unsigned int)c2 == ORD('(' /*)*/)) {

					*wp++ = OPAT;

					*wp++ = c;

					PUSH_STATE(SPATTERN);

					break;

				}

				ungetsc(c2);

			}

			/* FALLTHROUGH */

 Sbase2:		/* doesn't include *(...|...) pattern (*+?@!) */

			switch (c) {

			case ORD('\\'):

 getsc_qchar:

				if ((c = getsc())) {

					/* trailing \ is lost */

					*wp++ = QCHAR;

					*wp++ = c;

				}

				break;

			case ORD('\''):

 open_ssquote_unless_heredoc:

				if ((cf & HEREDOC))

					goto store_char;

				*wp++ = OQUOTE;

				ignore_backslash_newline++;

				PUSH_STATE(SSQUOTE);

				break;

			case ORD('"'):

 open_sdquote:

				*wp++ = OQUOTE;

				PUSH_STATE(SDQUOTE);

				break;

			case ORD('$'):

				/*

				 * processing of dollar sign belongs into

				 * Subst, except for those which can open

				 * a string: $'…' and $"…"

				 */

 subst_dollar_ex:

				c = getsc();

				switch (c) {

				case ORD('"'):

					goto open_sdquote;

				case ORD('\''):

					goto open_sequote;

				default:

					goto SubstS;

				}

			default:

				goto Subst;

			}

			break;

 Subst:

			switch (c) {

			case ORD('\\'):

				c = getsc();

				switch (c) {

				case ORD('"'):

					if ((cf & HEREDOC))

						goto heredocquote;

					/* FALLTHROUGH */

				case ORD('\\'):

				case ORD('$'):

				case ORD('`'):

 store_qchar:

					*wp++ = QCHAR;

					*wp++ = c;

					break;

				default:

 heredocquote:

					Xcheck(ws, wp);

					if (c) {

						/* trailing \ is lost */

						*wp++ = CHAR;

						*wp++ = '\\';

						*wp++ = CHAR;

						*wp++ = c;

					}

					break;

				}

				break;

			case ORD('$'):

				c = getsc();

 SubstS:

				if ((unsigned int)c == ORD('(' /*)*/)) {

					c = getsc();

					if ((unsigned int)c == ORD('(' /*)*/)) {

						*wp++ = EXPRSUB;

						PUSH_SRETRACE(SASPAREN);

						statep->nparen = 2;

						*retrace_info->xp++ = '(';

					} else {

						ungetsc(c);

 subst_command:

						c = COMSUB;

 subst_command2:

						sp = yyrecursive(c);

						cz = strlen(sp) + 1;

						XcheckN(ws, wp, cz);

						*wp++ = c;

						memcpy(wp, sp, cz);

						wp += cz;

					}

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

					if ((unsigned int)(c = getsc()) == ORD('|')) {

						/*

						 * non-subenvironment

						 * value substitution

						 */

						c = VALSUB;

						goto subst_command2;

					} else if (ctype(c, C_IFSWS)) {

						/*

						 * non-subenvironment

						 * "command" substitution

						 */

						c = FUNSUB;

						goto subst_command2;

					}

					ungetsc(c);

					*wp++ = OSUBST;

					*wp++ = '{' /*}*/;

					wp = get_brace_var(&ws, wp);

					c = getsc();

					/* allow :# and :% (ksh88 compat) */

					if ((unsigned int)c == ORD(':')) {

						*wp++ = CHAR;

						*wp++ = c;

						c = getsc();

						if ((unsigned int)c == ORD(':')) {

							*wp++ = CHAR;

							*wp++ = '0';

							*wp++ = ADELIM;

							*wp++ = ':';

							PUSH_STATE(SBRACE);

							PUSH_STATE(SADELIM);

							statep->ls_adelim.delimiter = ':';

							statep->ls_adelim.num = 1;

							statep->nparen = 0;

							break;

						} else if (ctype(c, C_DIGIT | C_DOLAR | C_SPC) ||

						    /*XXX what else? */

						    c == '(' /*)*/) {

							/* substring subst. */

							if (c != ' ') {

								*wp++ = CHAR;

								*wp++ = ' ';

							}

							ungetsc(c);

							PUSH_STATE(SBRACE);

							PUSH_STATE(SADELIM);

							statep->ls_adelim.delimiter = ':';

							statep->ls_adelim.num = 2;

							statep->nparen = 0;

							break;

						}

					} else if (c == '/') {

						c2 = ADELIM;

 parse_adelim_slash:

						*wp++ = CHAR;

						*wp++ = c;

						if ((unsigned int)(c = getsc()) == ORD('/')) {

							*wp++ = c2;

							*wp++ = c;

						} else

							ungetsc(c);

						PUSH_STATE(SBRACE);

						PUSH_STATE(SADELIM);

						statep->ls_adelim.delimiter = '/';

						statep->ls_adelim.num = 1;

						statep->nparen = 0;

						break;

					} else if (c == '@') {

						c2 = getsc();

						ungetsc(c2);

						if ((unsigned int)c2 == ORD('/')) {

							c2 = CHAR;

							goto parse_adelim_slash;

						}

					}

					/*

					 * If this is a trim operation,

					 * treat (,|,) specially in STBRACE.

					 */

					if (ctype(c, C_SUB2)) {

						ungetsc(c);

						if (Flag(FSH))

							PUSH_STATE(STBRACEBOURNE);

						else

							PUSH_STATE(STBRACEKORN);

					} else {

						ungetsc(c);

						if (state == SDQUOTE ||

						    state == SQBRACE)

							PUSH_STATE(SQBRACE);

						else

							PUSH_STATE(SBRACE);

					}

				} else if (ctype(c, C_ALPHX)) {

					*wp++ = OSUBST;

					*wp++ = 'X';

					do {

						Xcheck(ws, wp);

						*wp++ = c;

						c = getsc();

					} while (ctype(c, C_ALNUX));

					*wp++ = '\0';

					*wp++ = CSUBST;

					*wp++ = 'X';

					ungetsc(c);

				} else if (ctype(c, C_VAR1 | C_DIGIT)) {

					Xcheck(ws, wp);

					*wp++ = OSUBST;

					*wp++ = 'X';

					*wp++ = c;

					*wp++ = '\0';

					*wp++ = CSUBST;

					*wp++ = 'X';

				} else {

					*wp++ = CHAR;

					*wp++ = '$';

					ungetsc(c);

				}

				break;

			case ORD('`'):

 subst_gravis:

				PUSH_STATE(SBQUOTE);

				*wp++ = COMASUB;

				/*

				 * We need to know whether we are within double

				 * quotes in order to translate \" to " within

				 * "…`…\"…`…" because, unlike for COMSUBs, the

				 * outer double quoteing changes the backslash

				 * meaning for the inside. For more details:

				 * http://austingroupbugs.net/view.php?id=1015

				 */

				statep->ls_bool = false;

				s2 = statep;

				base = state_info.base;

				while (/* CONSTCOND */ 1) {

					for (; s2 != base; s2--) {

						if (s2->type == SDQUOTE) {

							statep->ls_bool = true;

							break;

						}

					}

					if (s2 != base)

						break;

					if (!(s2 = s2->ls_base))

						break;

					base = s2-- - STATE_BSIZE;

				}

				break;

			case QCHAR:

				if (cf & LQCHAR) {

					*wp++ = QCHAR;

					*wp++ = getsc();

					break;

				}

				/* FALLTHROUGH */

			default:

 store_char:

				*wp++ = CHAR;

				*wp++ = c;

			}

			break;

		case SEQUOTE:

			if ((unsigned int)c == ORD('\'')) {

				POP_STATE();

				*wp++ = CQUOTE;

				ignore_backslash_newline--;

			} else if ((unsigned int)c == ORD('\\')) {

				if ((c2 = unbksl(true, getsc_i, ungetsc)) == -1)

					c2 = getsc();

				if (c2 == 0)

					statep->ls_bool = true;

				if (!statep->ls_bool) {

					char ts[4];

					if ((unsigned int)c2 < 0x100) {

						*wp++ = QCHAR;

						*wp++ = c2;

					} else {

						cz = utf_wctomb(ts, c2 - 0x100);

						ts[cz] = 0;

						cz = 0;

						do {

							*wp++ = QCHAR;

							*wp++ = ts[cz];

						} while (ts[++cz]);

					}

				}

			} else if (!statep->ls_bool) {

				*wp++ = QCHAR;

				*wp++ = c;

			}

			break;

		case SSQUOTE:

			if ((unsigned int)c == ORD('\'')) {

				POP_STATE();

				if ((cf & HEREDOC) || state == SQBRACE)

					goto store_char;

				*wp++ = CQUOTE;

				ignore_backslash_newline--;

			} else {

				*wp++ = QCHAR;

				*wp++ = c;

			}

			break;

		case SDQUOTE:

			if ((unsigned int)c == ORD('"')) {

				POP_STATE();

				*wp++ = CQUOTE;

			} else

				goto Subst;

			break;

		/* $(( ... )) */

		case SASPAREN:

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

				statep->nparen++;

			else if ((unsigned int)c == ORD(')')) {

				statep->nparen--;

				if (statep->nparen == 1) {

					/* end of EXPRSUB */

					POP_SRETRACE();

					if ((unsigned int)(c2 = getsc()) == ORD(/*(*/ ')')) {

						cz = strlen(sp) - 2;

						XcheckN(ws, wp, cz);

						memcpy(wp, sp + 1, cz);

						wp += cz;

						afree(sp, ATEMP);

						*wp++ = '\0';

						break;

					} else {

						Source *s;

						ungetsc(c2);

						/*

						 * mismatched parenthesis -

						 * assume we were really

						 * parsing a $(...) expression

						 */

						--wp;

						s = pushs(SREREAD,

						    source->areap);

						s->start = s->str =

						    s->u.freeme = sp;

						s->next = source;

						source = s;

						goto subst_command;

					}

				}

			}

			/* reuse existing state machine */

			goto Sbase2;

		case SQBRACE:

			if ((unsigned int)c == ORD('\\')) {

				/*

				 * perform POSIX "quote removal" if the back-

				 * slash is "special", i.e. same cases as the

				 * {case '\\':} in Subst: plus closing brace;

				 * in mksh code "quote removal" on '\c' means

				 * write QCHAR+c, otherwise CHAR+\+CHAR+c are

				 * emitted (in heredocquote:)

				 */

				if ((unsigned int)(c = getsc()) == ORD('"') ||

				    (unsigned int)c == ORD('\\') ||

				    ctype(c, C_DOLAR | C_GRAVE) ||

				    (unsigned int)c == ORD(/*{*/ '}'))

					goto store_qchar;

				goto heredocquote;

			}

			goto common_SQBRACE;

		case SBRACE:

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

				goto open_ssquote_unless_heredoc;

			else if ((unsigned int)c == ORD('\\'))

				goto getsc_qchar;

 common_SQBRACE:

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

				goto open_sdquote;

			else if ((unsigned int)c == ORD('$'))

				goto subst_dollar_ex;

			else if ((unsigned int)c == ORD('`'))

				goto subst_gravis;

			else if ((unsigned int)c != ORD(/*{*/ '}'))

				goto store_char;

			POP_STATE();

			*wp++ = CSUBST;

			*wp++ = /*{*/ '}';

			break;

		/* Same as SBASE, except (,|,) treated specially */

		case STBRACEKORN:

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

				*wp++ = SPAT;

			else if ((unsigned int)c == ORD('(')) {

				*wp++ = OPAT;

				/* simile for @ */

				*wp++ = ' ';

				PUSH_STATE(SPATTERN);

			} else /* FALLTHROUGH */

		case STBRACEBOURNE:

			  if ((unsigned int)c == ORD(/*{*/ '}')) {

				POP_STATE();

				*wp++ = CSUBST;

				*wp++ = /*{*/ '}';

			} else

				goto Sbase1;

			break;

		case SBQUOTE:

			if ((unsigned int)c == ORD('`')) {

				*wp++ = 0;

				POP_STATE();

			} else if ((unsigned int)c == ORD('\\')) {

				switch (c = getsc()) {

				case 0:

					/* trailing \ is lost */

					break;

				case ORD('$'):

				case ORD('`'):

				case ORD('\\'):

					*wp++ = c;

					break;

				case ORD('"'):

					if (statep->ls_bool) {

						*wp++ = c;

						break;

					}

					/* FALLTHROUGH */

				default:

					*wp++ = '\\';

					*wp++ = c;

					break;

				}

			} else

				*wp++ = c;

			break;

		/* ONEWORD */

		case SWORD:

			goto Subst;

		/* LETEXPR: (( ... )) */

		case SLETPAREN:

			if ((unsigned int)c == ORD(/*(*/ ')')) {

				if (statep->nparen > 0)

					--statep->nparen;

				else if ((unsigned int)(c2 = getsc()) == ORD(/*(*/ ')')) {

					c = 0;

					*wp++ = CQUOTE;

					goto Done;

				} else {

					Source *s;

					ungetsc(c2);

					ungetsc(c);

					/*

					 * mismatched parenthesis -

					 * assume we were really

					 * parsing a (...) expression

					 */

					*wp = EOS;

					sp = Xstring(ws, wp);

					dp = wdstrip(sp + 1, WDS_TPUTS);

					s = pushs(SREREAD, source->areap);

					s->start = s->str = s->u.freeme = dp;

					s->next = source;

					source = s;

					ungetsc('(' /*)*/);

					return (ORD('(' /*)*/));

				}

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

				/*

				 * parentheses inside quotes and

				 * backslashes are lost, but AT&T ksh

				 * doesn't count them either

				 */

				++statep->nparen;

			goto Sbase2;

		/* << or <<- delimiter */

		case SHEREDELIM:

			/*

			 * here delimiters need a special case since

			 * $ and `...` are not to be treated specially

			 */

			switch (c) {

			case ORD('\\'):

				if ((c = getsc())) {

					/* trailing \ is lost */

					*wp++ = QCHAR;

					*wp++ = c;

				}

				break;

			case ORD('\''):

				goto open_ssquote_unless_heredoc;

			case ORD('$'):

				if ((unsigned int)(c2 = getsc()) == ORD('\'')) {

 open_sequote:

					*wp++ = OQUOTE;

					ignore_backslash_newline++;

					PUSH_STATE(SEQUOTE);

					statep->ls_bool = false;

					break;

				} else if ((unsigned int)c2 == ORD('"')) {

					/* FALLTHROUGH */

			case ORD('"'):

					PUSH_SRETRACE(SHEREDQUOTE);

					break;

				}

				ungetsc(c2);

				/* FALLTHROUGH */

			default:

				*wp++ = CHAR;

				*wp++ = c;

			}

			break;

		/* " in << or <<- delimiter */

		case SHEREDQUOTE:

			if ((unsigned int)c != ORD('"'))

				goto Subst;

			POP_SRETRACE();

			dp = strnul(sp) - 1;

			/* remove the trailing double quote */

			*dp = '\0';

			/* store the quoted string */

			*wp++ = OQUOTE;

			XcheckN(ws, wp, (dp - sp) * 2);

			dp = sp;

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

				if (c == '\\') {

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

					case ORD('\\'):

					case ORD('"'):

					case ORD('$'):

					case ORD('`'):

						break;

					default:

						*wp++ = CHAR;

						*wp++ = '\\';

						break;

					}

				}

				*wp++ = CHAR;

				*wp++ = c;

			}

			afree(sp, ATEMP);

			*wp++ = CQUOTE;

			state = statep->type = SHEREDELIM;

			break;

		/* in *(...|...) pattern (*+?@!) */

		case SPATTERN:

			if ((unsigned int)c == ORD(/*(*/ ')')) {

				*wp++ = CPAT;

				POP_STATE();

			} else if ((unsigned int)c == ORD('|')) {

				*wp++ = SPAT;

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

				*wp++ = OPAT;

				/* simile for @ */

				*wp++ = ' ';

				PUSH_STATE(SPATTERN);

			} else

				goto Sbase1;

			break;

		}

	}

 Done: