/*

 * 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 "prompt.pro"

#ifdef __SYMBIAN32__

#ifdef __WINSCW__

#pragma warn_possunwant off

#endif//__WINSCW__

#endif//__SYMBIAN32__

/* text attribute mask */

/**/

unsigned txtattrmask;

/* text change - attribute change made by prompts */

/**/

mod_export unsigned txtchange;

/* the command stack for use with %_ in prompts */

/**/

unsigned char *cmdstack;

/**/

int cmdsp;

/* parser states, for %_ */

static char *cmdnames[CS_COUNT] = {

    "for",      "while",     "repeat",    "select",

    "until",    "if",        "then",      "else",

    "elif",     "math",      "cond",      "cmdor",

    "cmdand",   "pipe",      "errpipe",   "foreach",

    "case",     "function",  "subsh",     "cursh",

    "array",    "quote",     "dquote",    "bquote",

    "cmdsubst", "mathsubst", "elif-then", "heredoc",

    "heredocd", "brace",     "braceparam", "always",

};

/* The buffer into which an expanded and metafied prompt is being written, *

 * and its size.                                                           */

static char *buf;

static int bufspc;

/* bp is the pointer to the current position in the buffer, where the next *

 * character will be added.                                                */

static char *bp;

/* Position of the start of the current line in the buffer */

static char *bufline;

/* bp1 is an auxiliary pointer into the buffer, which when non-NULL is *

 * moved whenever the buffer is reallocated.  It is used when data is   *

 * being temporarily held in the buffer.                                */

static char *bp1;

/* The format string, for %-expansion. */

static char *fm;

/* Non-zero if truncating the current segment of the buffer. */

static int trunclen;

/* Current level of nesting of %{ / %} sequences. */

static int dontcount;

/* Level of %{ / %} surrounding a truncation segment. */

static int trunccount;

/* Strings to use for %r and %R (for the spelling prompt). */

static char *rstring, *Rstring;

/*

 * Expand path p; maximum is npath segments where 0 means the whole path.

 * If tilde is 1, try and find a named directory to use.

 */

static void

promptpath(char *p, int npath, int tilde)

{

    char *modp = p;

    Nameddir nd;

    if (tilde && ((nd = finddir(p))))

	modp = tricat("~", nd->nam, p + strlen(nd->dir));

    if (npath) {

	char *sptr;

	if (npath > 0) {

	    for (sptr = modp + strlen(modp); sptr > modp; sptr--) {

		if (*sptr == '/' && !--npath) {

		    sptr++;

		    break;

		}

	    }

	    if (*sptr == '/' && sptr[1] && sptr != modp)

		sptr++;

	    stradd(sptr);

	} else {

	    char cbu;

	    for (sptr = modp+1; *sptr; sptr++)

		if (*sptr == '/' && !++npath)

		    break;

	    cbu = *sptr;

	    *sptr = 0;

	    stradd(modp);

	    *sptr = cbu;

	}

    } else

	stradd(modp);

    if (p != modp)

	zsfree(modp);

}

/* Perform prompt expansion on a string, putting the result in a *

 * permanently-allocated string.  If ns is non-zero, this string *

 * may have embedded Inpar and Outpar, which indicate a toggling *

 * between spacing and non-spacing parts of the prompt, and      *

 * Nularg, which (in a non-spacing sequence) indicates a         *

 * `glitch' space.                                               */

/**/

mod_export char *

promptexpand(char *s, int ns, char *rs, char *Rs)

{

    if(!s)

	return ztrdup("");

    if ((termflags & TERM_UNKNOWN) && (unset(INTERACTIVE)))

        init_term();

    if (isset(PROMPTSUBST)) {

	int olderr = errflag;

	int oldval = lastval;

	s = dupstring(s);

	if (!parsestr(s))

	    singsub(&s);

	/* Ignore errors and status change in prompt substitution */

	errflag = olderr;

	lastval = oldval;

    }

    rstring = rs;

    Rstring = Rs;

    fm = s;

    bp = bufline = buf = zshcalloc(bufspc = 256);

    bp1 = NULL;

    trunclen = 0;

    putpromptchar(1, '\0');

    addbufspc(1);

    if(dontcount)

	*bp++ = Outpar;

    *bp = 0;

    if (!ns) {

	/* If zero, Inpar, Outpar and Nularg should be removed. */

	for (bp = buf; *bp; ) {

	    if (*bp == Meta)

		bp += 2;

	    else if (*bp == Inpar || *bp == Outpar || *bp == Nularg)

		chuck(bp);

	    else

		bp++;

	}

    }

    return buf;

}

/* Perform %- and !-expansion as required on a section of the prompt.  The *

 * section is ended by an instance of endchar.  If doprint is 0, the valid *

 * % sequences are merely skipped over, and nothing is stored.             */

/**/

static int

putpromptchar(int doprint, int endchar)

{

    char *ss, *tmbuf = NULL, *hostnam;

    int t0, arg, test, sep, j, numjobs;

    struct tm *tm;

    time_t timet;

    Nameddir nd;

    for (; *fm && *fm != endchar; fm++) {

	arg = 0;

	if (*fm == '%' && isset(PROMPTPERCENT)) {

	    int minus = 0;

	    fm++;

	    if (*fm == '-') {

		minus = 1;

		fm++;

	    }

	    if (idigit(*fm)) {

		arg = zstrtol(fm, &fm, 10);

		if (minus)

		    arg *= -1;

	    } else if (minus)

		arg = -1;

	    if (*fm == '(') {

		int tc, otrunclen;

		if (idigit(*++fm)) {

		    arg = zstrtol(fm, &fm, 10);

		} else if (arg < 0) {

		    /* negative numbers don't make sense here */

		    arg *= -1;

		}

		test = 0;

		ss = pwd;

		switch (tc = *fm) {

		case 'c':

		case '.':

		case '~':

		    if ((nd = finddir(ss))) {

			arg--;

			ss += strlen(nd->dir);

		    } /*FALLTHROUGH*/

		case '/':

		case 'C':

		    /* `/' gives 0, `/any' gives 1, etc. */

		    if (*ss++ == '/' && *ss)

			arg--;

		    for (; *ss; ss++)

			if (*ss == '/')

			    arg--;

		    if (arg <= 0)

			test = 1;

		    break;

		case 't':

		case 'T':

		case 'd':

		case 'D':

		case 'w':

		    timet = time(NULL);

		    tm = localtime(&timet);

		    switch (tc) {

		    case 't':

			test = (arg == tm->tm_min);

			break;

		    case 'T':

			test = (arg == tm->tm_hour);

			break;

		    case 'd':

			test = (arg == tm->tm_mday);

			break;

		    case 'D':

			test = (arg == tm->tm_mon);

			break;

		    case 'w':

			test = (arg == tm->tm_wday);

			break;

		    }

		    break;

		case '?':

		    if (lastval == arg)

			test = 1;

		    break;

		case '#':

		    if (geteuid() == (uid_t)arg)

			test = 1;

		    break;

		case 'g':

		    if (getegid() == (gid_t)arg)

			test = 1;

		    break;

		case 'j':

		    for (numjobs = 0, j = 1; j <= maxjob; j++)

			if (jobtab[j].stat && jobtab[j].procs &&

		    	    !(jobtab[j].stat & STAT_NOPRINT)) numjobs++;

		    if (numjobs >= arg)

		    	test = 1;

		    break;

		case 'l':

		    *bp = '\0';

		    countprompt(bufline, &t0, 0, 0);

		    if (t0 >= arg)

			test = 1;

		    break;

		case 'L':

		    if (shlvl >= arg)

			test = 1;

		    break;

		case 'S':

		    if (time(NULL) - shtimer.tv_sec >= arg)

			test = 1;

		    break;

		case 'v':

		    if (arrlen(psvar) >= arg)

			test = 1;

		    break;

		case '_':

		    test = (cmdsp >= arg);

		    break;

		case '!':

		    test = privasserted();

		    break;

		default:

		    test = -1;

		    break;

		}

		if (!*fm || !(sep = *++fm))

		    return 0;

		fm++;

		/* Don't do the current truncation until we get back */

		otrunclen = trunclen;

		trunclen = 0;

		if (!putpromptchar(test == 1 && doprint, sep) || !*++fm ||

		    !putpromptchar(test == 0 && doprint, ')')) {

		    trunclen = otrunclen;

		    return 0;

		}

		trunclen = otrunclen;

		continue;

	    }

	    if (!doprint)

		switch(*fm) {

		  case '[':

		    while(idigit(*++fm));

		    while(*++fm != ']');

		    continue;

		  case '<':

		    while(*++fm != '<');

		    continue;

		  case '>':

		    while(*++fm != '>');

		    continue;

		  case 'D':

		    if(fm[1]=='{')

			while(*++fm != '}');

		    continue;

		  default:

		    continue;

		}

	    switch (*fm) {

	    case '~':

		promptpath(pwd, arg, 1);

		break;

	    case 'd':

	    case '/':

		promptpath(pwd, arg, 0);

		break;

	    case 'c':

	    case '.':

		promptpath(pwd, arg ? arg : 1, 1);

		break;

	    case 'C':

		promptpath(pwd, arg ? arg : 1, 0);

		break;

	    case 'N':

		promptpath(scriptname ? scriptname : argzero, arg, 0);

		break;

	    case 'h':

	    case '!':

		addbufspc(DIGBUFSIZE);

		convbase(bp, curhist, 10);

		bp += strlen(bp);

		break;

	    case 'j':

		for (numjobs = 0, j = 1; j <= maxjob; j++)

		    if (jobtab[j].stat && jobtab[j].procs &&

		    	!(jobtab[j].stat & STAT_NOPRINT)) numjobs++;

		addbufspc(DIGBUFSIZE);

		sprintf(bp, "%d", numjobs);

		bp += strlen(bp);

		break;

	    case 'M':

		queue_signals();

		if ((hostnam = getsparam("HOST")))

		    stradd(hostnam);

		unqueue_signals();

		break;

	    case 'm':

		if (!arg)

		    arg++;

		queue_signals();

		if (!(hostnam = getsparam("HOST")))

		    break;

		if (arg < 0) {

		    for (ss = hostnam + strlen(hostnam); ss > hostnam; ss--)

			if (ss[-1] == '.' && !++arg)

			    break;

		    stradd(ss);

		} else {

		    for (ss = hostnam; *ss; ss++)

			if (*ss == '.' && !--arg)

			    break;

		    stradd(*ss ? dupstrpfx(hostnam, ss - hostnam) : hostnam);

		}

		unqueue_signals();

		break;

	    case 'S':

		txtchangeset(TXTSTANDOUT, TXTNOSTANDOUT);

		txtset(TXTSTANDOUT);

		tsetcap(TCSTANDOUTBEG, 1);

		break;

	    case 's':

		txtchangeset(TXTNOSTANDOUT, TXTSTANDOUT);

		txtset(TXTDIRTY);

		txtunset(TXTSTANDOUT);

		tsetcap(TCSTANDOUTEND, 1);

		break;

	    case 'B':

		txtchangeset(TXTBOLDFACE, TXTNOBOLDFACE);

		txtset(TXTDIRTY);

		txtset(TXTBOLDFACE);

		tsetcap(TCBOLDFACEBEG, 1);

		break;

	    case 'b':

		txtchangeset(TXTNOBOLDFACE, TXTBOLDFACE);

		txtchangeset(TXTNOSTANDOUT, TXTSTANDOUT);

		txtchangeset(TXTNOUNDERLINE, TXTUNDERLINE);

		txtset(TXTDIRTY);

		txtunset(TXTBOLDFACE);

		tsetcap(TCALLATTRSOFF, 1);

		break;

	    case 'U':

		txtchangeset(TXTUNDERLINE, TXTNOUNDERLINE);

		txtset(TXTUNDERLINE);

		tsetcap(TCUNDERLINEBEG, 1);

		break;

	    case 'u':

		txtchangeset(TXTNOUNDERLINE, TXTUNDERLINE);

		txtset(TXTDIRTY);

		txtunset(TXTUNDERLINE);

		tsetcap(TCUNDERLINEEND, 1);

		break;

	    case '[':

		if (idigit(*++fm))

		    arg = zstrtol(fm, &fm, 10);

		if (!prompttrunc(arg, ']', doprint, endchar))

		    return *fm;

		break;

	    case '<':

	    case '>':

		if (!prompttrunc(arg, *fm, doprint, endchar))

		    return *fm;

		break;

	    case '{': /*}*/

		if (!dontcount++) {

		    addbufspc(1);

		    *bp++ = Inpar;

		}

		break;

	    case /*{*/ '}':

		if (trunccount && trunccount >= dontcount)

		    return *fm;

		if (dontcount && !--dontcount) {

		    addbufspc(1);

		    *bp++ = Outpar;

		}

		break;

	    case 't':

	    case '@':

	    case 'T':

	    case '*':

	    case 'w':

	    case 'W':

	    case 'D':

		{

		    char *tmfmt, *dd;

		    switch (*fm) {

		    case 'T':

			tmfmt = "%K:%M";

			break;

		    case '*':

			tmfmt = "%K:%M:%S";

			break;

		    case 'w':

			tmfmt = "%a %f";

			break;

		    case 'W':

			tmfmt = "%m/%d/%y";

			break;

		    case 'D':

			if (fm[1] == '{' /*}*/) {

			    for (ss = fm + 2; *ss && *ss != /*{*/ '}'; ss++)

				if(*ss == '\\' && ss[1])

				    ss++;

			    dd = tmfmt = tmbuf = zalloc(ss - fm);

			    for (ss = fm + 2; *ss && *ss != /*{*/ '}';

				 ss++) {

				if(*ss == '\\' && ss[1])

				    ss++;

				*dd++ = *ss;

			    }

			    *dd = 0;

			    fm = ss - !*ss;

			    if (!*tmfmt) {

				free(tmbuf);