/*

 * This file is part of zsh, the Z shell.

 *

 * Copyright (c) 1992-1997 Paul Falstad

 * All rights reserved.

 *

 * Permission is hereby granted, without written agreement and without

 * license or royalty fees, to use, copy, modify, and distribute this

 * software and to distribute modified versions of this software for any

 * purpose, provided that the above copyright notice and the following

 * two paragraphs appear in all copies of this software.

 *

 * In no event shall Paul Falstad or the Zsh Development Group be liable

 * to any party for direct, indirect, special, incidental, or consequential

 * damages arising out of the use of this software and its documentation,

 * even if Paul Falstad and the Zsh Development Group have been advised of

 * the possibility of such damage.

 *

 * Paul Falstad and the Zsh Development Group specifically disclaim any

 * warranties, including, but not limited to, the implied warranties of

 * merchantability and fitness for a particular purpose.  The software

 * provided hereunder is on an "as is" basis, and Paul Falstad and the

 * Zsh Development Group have no obligation to provide maintenance,

 * support, updates, enhancements, or modifications.

 *

 */

#include "zsh.mdh"

#include "subst.pro"

#ifdef __SYMBIAN32__

#ifdef __WINSCW__

#pragma warn_possunwant off

#endif//__WINSCW__

#endif//__SYMBIAN32__

/**/

char nulstring[] = {Nularg, '\0'};

/* Do substitutions before fork. These are:

 *  - Process substitution: <(...), >(...), =(...)

 *  - Parameter substitution

 *  - Command substitution

 * Followed by

 *  - Quote removal

 *  - Brace expansion

 *  - Tilde and equals substitution

 *

 * PF_* flags are defined in zsh.h

 */

/**/

mod_export void

prefork(LinkList list, int flags)

{

    LinkNode node, stop = 0;

    int keep = 0, asssub = (flags & PF_TYPESET) && isset(KSHTYPESET);

    queue_signals();

    for (node = firstnode(list); node; incnode(node)) {

	char *str, c;

	str = (char *)getdata(node);

	if (((c = *str) == Inang || c == Outang || c == Equals) &&

	    str[1] == Inpar) {

	    if (c == Inang || c == Outang)

		setdata(node, (void *) getproc(str));	/* <(...) or >(...) */

	    else

		setdata(node, (void *) getoutputfile(str));	/* =(...) */

	    if (!getdata(node)) {

		unqueue_signals();

		return;

	    }

	} else {

	    if (isset(SHFILEEXPANSION))

		filesub((char **)getaddrdata(node),

			flags & (PF_TYPESET|PF_ASSIGN));

	    if (!(node = stringsubst(list, node, flags & PF_SINGLE, asssub))) {

		unqueue_signals();

		return;

	    }

	}

    }

    for (node = firstnode(list); node; incnode(node)) {

	if (node == stop)

	    keep = 0;

	if (*(char *)getdata(node)) {

	    remnulargs(getdata(node));

	    if (unset(IGNOREBRACES) && !(flags & PF_SINGLE)) {

		if (!keep)

		    stop = nextnode(node);

		while (hasbraces(getdata(node))) {

		    keep = 1;

		    xpandbraces(list, &node);

		}

	    }

	    if (unset(SHFILEEXPANSION))

		filesub((char **)getaddrdata(node),

			flags & (PF_TYPESET|PF_ASSIGN));

	} else if (!(flags & PF_SINGLE) && !keep)

	    uremnode(list, node);

	if (errflag) {

	    unqueue_signals();

	    return;

	}

    }

    unqueue_signals();

}

/**/

static LinkNode

stringsubst(LinkList list, LinkNode node, int ssub, int asssub)

{

    int qt;

    char *str3 = (char *)getdata(node);

    char *str  = str3, c;

    while (!errflag && (c = *str)) {

	if ((qt = c == Qstring) || c == String) {

	    if ((c = str[1]) == Inpar) {

		if (!qt)

		    mult_isarr = 1;

		str++;

		goto comsub;

	    } else if (c == Inbrack) {

		/* $[...] */

		char *str2 = str;

		str2++;

		if (skipparens(Inbrack, Outbrack, &str2)) {

		    zerr("closing bracket missing", NULL, 0);

		    return NULL;

		}

		str2[-1] = *str = '\0';

		str = arithsubst(str + 2, &str3, str2);

		setdata(node, (void *) str3);

		continue;

	    } else if (c == Snull) {

		str = getkeystring(str, NULL, 4, NULL);

		continue;

	    } else {

		node = paramsubst(list, node, &str, qt, ssub);

		if (errflag || !node)

		    return NULL;

		str3 = (char *)getdata(node);

		continue;

	    }

	} else if ((qt = c == Qtick) || (c == Tick ? (mult_isarr = 1) : 0))

	  comsub: {

	    LinkList pl;

	    char *s, *str2 = str;

	    char endchar;

	    int l1, l2;

	    if (c == Inpar) {

		endchar = Outpar;

		str[-1] = '\0';

#ifdef DEBUG

		if (skipparens(Inpar, Outpar, &str))

		    dputs("BUG: parse error in command substitution");

#else

		skipparens(Inpar, Outpar, &str);

#endif

		str--;

	    } else {

		endchar = c;

		*str = '\0';

		while (*++str != endchar)

		    DPUTS(!*str, "BUG: parse error in command substitution");

	    }

	    *str++ = '\0';

	    if (endchar == Outpar && str2[1] == '(' && str[-2] == ')') {

		/* Math substitution of the form $((...)) */

		str[-2] = '\0';

		str = arithsubst(str2 + 2, &str3, str);

		setdata(node, (void *) str3);

		continue;

	    }

	    /* It is a command substitution, which will be parsed again   *

	     * by the lexer, so we untokenize it first, but we cannot use *

	     * untokenize() since in the case of `...` some Bnulls should *

	     * be left unchanged.  Note that the lexer doesn't tokenize   *

	     * the body of a command substitution so if there are some    *

	     * tokens here they are from a ${(e)~...} substitution.       */

	    for (str = str2; (c = *++str); )

		if (itok(c) && c != Nularg &&

		    !(endchar != Outpar && c == Bnull &&

		      (str[1] == '$' || str[1] == '\\' || str[1] == '`' ||

		       (qt && str[1] == '"'))))

		    *str = ztokens[c - Pound];

	    str++;

	    if (!(pl = getoutput(str2 + 1, qt || ssub))) {

		zerr("parse error in command substitution", NULL, 0);

		return NULL;

	    }

	    if (endchar == Outpar)

		str2--;

	    if (!(s = (char *) ugetnode(pl))) {

		str = strcpy(str2, str);

		continue;

	    }

	    if (!qt && ssub && isset(GLOBSUBST))

		shtokenize(s);

	    l1 = str2 - str3;

	    l2 = strlen(s);

	    if (nonempty(pl)) {

		LinkNode n = lastnode(pl);

		str2 = (char *) hcalloc(l1 + l2 + 1);

		strcpy(str2, str3);

		strcpy(str2 + l1, s);

		setdata(node, str2);

		insertlinklist(pl, node, list);

		s = (char *) getdata(node = n);

		l1 = 0;

		l2 = strlen(s);

	    }

	    str2 = (char *) hcalloc(l1 + l2 + strlen(str) + 1);

	    if (l1)

		strcpy(str2, str3);

	    strcpy(str2 + l1, s);

	    str = strcpy(str2 + l1 + l2, str);

	    str3 = str2;

	    setdata(node, str3);

	    continue;

	} else if (asssub && ((c == '=') || c == Equals) && str != str3) {

	    /*

	     * We are in a normal argument which looks like an assignment

	     * and is to be treated like one, with no word splitting.

	     */

	    ssub = 1;

	}

	str++;

    }

    return errflag ? NULL : node;

}

/*

 * Simplified version of the prefork/singsub processing where

 * we only do substitutions appropriate to quoting.  Currently

 * this means only the expansions in $'....'.  This is used

 * for the end tag for here documents.  As we are not doing

 * `...` expansions, we just use those for quoting.  However,

 * they stay in the text.  This is weird, but that's not

 * my fault.

 *

 * The remnulargs() makes this consistent with the other forms

 * of substitution, indicating that quotes have been fully

 * processed.

 */

/**/

void

quotesubst(char *str)

{

    char *s = str;

    while (*s) {

	if (*s == String && s[1] == Snull) {

	    s = getkeystring(s, NULL, 4, NULL);

	} else {

	    s++;

	}

    }

    remnulargs(str);

}

/**/

mod_export void

globlist(LinkList list, int nountok)

{

    LinkNode node, next;

    badcshglob = 0;

    for (node = firstnode(list); !errflag && node; node = next) {

	next = nextnode(node);

	zglob(list, node, nountok);

    }

    if (badcshglob == 1)

	zerr("no match", NULL, 0);

}

/* perform substitution on a single word */

/**/

mod_export void

singsub(char **s)

{

    int omi = mult_isarr;

    local_list1(foo);

    init_list1(foo, *s);

    prefork(&foo, PF_SINGLE);

    mult_isarr = omi;

    if (errflag)

	return;

    *s = (char *) ugetnode(&foo);

    DPUTS(nonempty(&foo), "BUG: singsub() produced more than one word!");

}

/* Perform substitution on a single word. Unlike with singsub, the      *

 * result can have more than one word. A single word result is stored   *

 * in *s and *isarr is set to zero; otherwise *isarr is set to 1 and    *

 * the result is stored in *a. If `a' is zero a multiple word result is *

 * joined using sep or the IFS parameter if sep is zero and the result  *

 * is returned in *s.  The return value is true iff the expansion       *

 * resulted in an empty list.                                           *

 * The mult_isarr variable is used by paramsubst() to tell if it yields *

 * an array.                                                            */

/**/

static int mult_isarr;

/**/

static int

multsub(char **s, char ***a, int *isarr, UNUSED(char *sep))

{

    int l, omi = mult_isarr;

    char **r, **p;

    local_list1(foo);

#ifdef __SYMBIAN32__

	sep=sep;

#endif

    mult_isarr = 0;

    init_list1(foo, *s);

    prefork(&foo, 0);

    if (errflag) {

	if (isarr)

	    *isarr = 0;

	mult_isarr = omi;

	return 0;

    }

    if ((l = countlinknodes(&foo))) {

	p = r = hcalloc((l + 1) * sizeof(char*));

	while (nonempty(&foo))

	    *p++ = (char *)ugetnode(&foo);

	*p = NULL;

	/*

	 * This is the most obscure way of deciding whether a value is

	 * an array it would be possible to imagine.  It seems to result

	 * partly because we don't pass down the qt and ssub flags from

	 * paramsubst() through prefork() properly, partly because we

	 * don't tidy up to get back the return type from multsub we

	 * need properly.  The crux of neatening this up is to get rid

	 * of the following test.

	 */

	if (a && mult_isarr) {

	    *a = r;

	    *isarr = SCANPM_MATCHMANY;

	    mult_isarr = omi;

	    return 0;

	}

	*s = sepjoin(r, NULL, 1);

	mult_isarr = omi;

	if (isarr)

	    *isarr = 0;

	return 0;

    }

    if (l)

	*s = (char *) ugetnode(&foo);

    else

	*s = dupstring("");

    if (isarr)

	*isarr = 0;

    mult_isarr = omi;

    return !l;

}

/*

 * ~, = subs: assign & PF_TYPESET => typeset or magic equals

 *            assign & PF_ASSIGN => normal assignment

 */

/**/

mod_export void

filesub(char **namptr, int assign)

{

    char *eql = NULL, *sub = NULL, *str, *ptr;

    int len;

    filesubstr(namptr, assign);

    if (!assign)

	return;

    if (assign & PF_TYPESET) {

	if ((*namptr)[1] && (eql = sub = strchr(*namptr + 1, Equals))) {

	    str = sub + 1;

	    if ((sub[1] == Tilde || sub[1] == Equals) && filesubstr(&str, assign)) {

		sub[1] = '\0';

		*namptr = dyncat(*namptr, str);

	    }

	} else

	    return;

    }

    ptr = *namptr;

    while ((sub = strchr(ptr, ':'))) {

	str = sub + 1;

	len = sub - *namptr;

	if (sub > eql &&

	    (sub[1] == Tilde || sub[1] == Equals) &&

	    filesubstr(&str, assign)) {

	    sub[1] = '\0';

	    *namptr = dyncat(*namptr, str);

	}

	ptr = *namptr + len + 1;

    }

}

/**/

mod_export int

filesubstr(char **namptr, int assign)

{

#define isend(c) ( !(c) || (c)=='/' || (c)==Inpar || (assign && (c)==':') )

#define isend2(c) ( !(c) || (c)==Inpar || (assign && (c)==':') )

    char *str = *namptr;

    if (*str == Tilde && str[1] != '=' && str[1] != Equals) {

	char *ptr;

	int val;

	val = zstrtol(str + 1, &ptr, 10);

	if (isend(str[1])) {   /* ~ */

	    *namptr = dyncat(home, str + 1);

	    return 1;

	} else if (str[1] == '+' && isend(str[2])) {   /* ~+ */

	    *namptr = dyncat(pwd, str + 2);

	    return 1;

	} else if (str[1] == '-' && isend(str[2])) {   /* ~- */

	    char *tmp;

	    *namptr = dyncat((tmp = oldpwd) ? tmp : pwd, str + 2);

	    return 1;

	} else if (!inblank(str[1]) && isend(*ptr) &&

		   (!idigit(str[1]) || (ptr - str < 4))) {

	    char *ds;

	    if (val < 0)

		val = -val;

	    ds = dstackent(str[1], val);

	    if (!ds)

		return 0;

	    *namptr = dyncat(ds, ptr);

	    return 1;

	} else if (iuser(str[1])) {   /* ~foo */

	    char *ptr, *hom, save;

	    for (ptr = ++str; *ptr && iuser(*ptr); ptr++);

	    save = *ptr;

	    if (!isend(save))

		return 0;

	    *ptr = 0;

	    if (!(hom = getnameddir(str))) {

		if (isset(NOMATCH))

		    zerr("no such user or named directory: %s", str, 0);

		*ptr = save;

		return 0;

	    }

	    *ptr = save;

	    *namptr = dyncat(hom, ptr);

	    return 1;

	}

    } else if (*str == Equals && isset(EQUALS) && str[1]) {   /* =foo */

	char sav, *pp, *cnam;

	for (pp = str + 1; !isend2(*pp); pp++);

	sav = *pp;

	*pp = 0;

	if (!(cnam = findcmd(str + 1, 1))) {

	    if (isset(NOMATCH))

		zerr("%s not found", str + 1, 0);

	    return 0;

	}

	*namptr = dupstring(cnam);

	if (sav) {

	    *pp = sav;

	    *namptr = dyncat(*namptr, pp);

	}

	return 1;

    }

    return 0;

#undef isend

#undef isend2

}

/**/

static char *

strcatsub(char **d, char *pb, char *pe, char *src, int l, char *s, int glbsub,

	  int copied)

{

    char *dest;

    int pl = pe - pb;

    if (!pl && (!s || !*s)) {

	*d = dest = (copied ? src : dupstring(src));

	if (glbsub)

	    shtokenize(dest);

    } else {

	*d = dest = hcalloc(pl + l + (s ? strlen(s) : 0) + 1);

	strncpy(dest, pb, pl);

	dest += pl;

	strcpy(dest, src);

	if (glbsub)

	    shtokenize(dest);

	dest += l;

	if (s)