int
evalcond(Estate state, char *fromtest)
{
struct stat *st;
char *left, *right, *overridename, overridebuf[13];
Wordcode pcode;
wordcode code;
int ctype, htok = 0, ret;
rec:
left = right = overridename = NULL;
pcode = state->pc++;
code = *pcode;
ctype = WC_COND_TYPE(code);
switch (ctype) {
case COND_NOT:
if (tracingcond)
fprintf(xtrerr, " %s", condstr[ctype]);
ret = evalcond(state, fromtest);
if (ret == 2)
return ret;
else
return !ret;
case COND_AND:
if (!(ret = evalcond(state, fromtest))) {
if (tracingcond)
fprintf(xtrerr, " %s", condstr[ctype]);
goto rec;
} else {
state->pc = pcode + (WC_COND_SKIP(code) + 1);
return ret;
}
case COND_OR:
if ((ret = evalcond(state, fromtest)) == 1) {
if (tracingcond)
fprintf(xtrerr, " %s", condstr[ctype]);
goto rec;
} else {
state->pc = pcode + (WC_COND_SKIP(code) + 1);
return ret;
}
case COND_REGEX:
{
char *modname = isset(REMATCHPCRE) ? "zsh/pcre" : "zsh/regex";
sprintf(overridename = overridebuf, "-%s-match", modname+4);
(void)ensurefeature(modname, "C:", overridename+1);
ctype = COND_MODI;
}
/*FALLTHROUGH*/
case COND_MOD:
case COND_MODI:
{
Conddef cd;
char *name = overridename, *errname;
char **strs;
int l = WC_COND_SKIP(code);
if (name == NULL)
name = ecgetstr(state, EC_NODUP, NULL);
if (ctype == COND_MOD)
strs = ecgetarr(state, l, EC_DUP, NULL);
else {
char *sbuf[3];
sbuf[0] = ecgetstr(state, EC_NODUP, NULL);
sbuf[1] = ecgetstr(state, EC_NODUP, NULL);
sbuf[2] = NULL;
strs = arrdup(sbuf);
l = 2;
}
if (name && name[0] == '-')
errname = name;
else if (strs[0] && *strs[0] == '-')
errname = strs[0];
else
errname = "<null>";
if (name && name[0] == '-' &&
(cd = getconddef((ctype == COND_MODI), name + 1, 1))) {
if (ctype == COND_MOD &&
(l < cd->min || (cd->max >= 0 && l > cd->max))) {
zwarnnam(fromtest, "unknown condition: %s", name);
return 2;
}
if (tracingcond)
tracemodcond(name, strs, ctype == COND_MODI);
return !cd->handler(strs, cd->condid);
}
else {
char *s = strs[0];
if (overridename) {
/*
* Standard regex function not available: this
* is a hard error.
*/
zerrnam(fromtest, "%s not available for regex",
overridename);
return 2;
}
strs[0] = dupstring(name);
name = s;
if (name && name[0] == '-' &&
(cd = getconddef(0, name + 1, 1))) {
if (l < cd->min || (cd->max >= 0 && l > cd->max)) {
zwarnnam(fromtest, "unknown condition: %s",
errname);
return 2;
}
if (tracingcond)
tracemodcond(name, strs, ctype == COND_MODI);
return !cd->handler(strs, cd->condid);
} else {
zwarnnam(fromtest,
"unknown condition: %s",
errname);
}
}
/* module not found, error */
return 2;
}
}
left = ecgetstr(state, EC_DUPTOK, &htok);
if (htok) {
cond_subst(&left, !fromtest);
untokenize(left);
}
if (ctype <= COND_GE && ctype != COND_STREQ && ctype != COND_STRNEQ) {
right = ecgetstr(state, EC_DUPTOK, &htok);
if (htok) {
cond_subst(&right, !fromtest);
untokenize(right);
}
}
if (tracingcond) {
if (ctype < COND_MOD) {
fputc(' ',xtrerr);
quotedzputs(left, xtrerr);
fprintf(xtrerr, " %s ", condstr[ctype]);
if (ctype == COND_STREQ || ctype == COND_STRNEQ) {
char *rt = dupstring(ecrawstr(state->prog, state->pc, NULL));
cond_subst(&rt, !fromtest);
quote_tokenized_output(rt, xtrerr);
}
else
quotedzputs((char *)right, xtrerr);
} else {
fprintf(xtrerr, " -%c ", ctype);
quotedzputs(left, xtrerr);
}
}
if (ctype >= COND_EQ && ctype <= COND_GE) {
mnumber mn1, mn2;
if (fromtest) {
/*
* For test and [, the expressions must be base 10 integers,
* not integer expressions.
*/
char *eptr, *err;
mn1.u.l = zstrtol(left, &eptr, 10);
if (!*eptr)
{
mn2.u.l = zstrtol(right, &eptr, 10);
err = right;
}
else
err = left;
if (*eptr)
{
zwarnnam(fromtest, "integer expression expected: %s", err);
return 2;
}
mn1.type = mn2.type = MN_INTEGER;
} else {
mn1 = matheval(left);
mn2 = matheval(right);
}
if (((mn1.type|mn2.type) & (MN_INTEGER|MN_FLOAT)) ==
(MN_INTEGER|MN_FLOAT)) {
/* promote to float */
if (mn1.type & MN_INTEGER) {
mn1.type = MN_FLOAT;
mn1.u.d = (double)mn1.u.l;
}
if (mn2.type & MN_INTEGER) {
mn2.type = MN_FLOAT;
mn2.u.d = (double)mn2.u.l;
}
}
switch(ctype) {
case COND_EQ:
return !((mn1.type & MN_FLOAT) ? (mn1.u.d == mn2.u.d) :
(mn1.u.l == mn2.u.l));
case COND_NE:
return !((mn1.type & MN_FLOAT) ? (mn1.u.d != mn2.u.d) :
(mn1.u.l != mn2.u.l));
case COND_LT:
return !((mn1.type & MN_FLOAT) ? (mn1.u.d < mn2.u.d) :
(mn1.u.l < mn2.u.l));
case COND_GT:
return !((mn1.type & MN_FLOAT) ? (mn1.u.d > mn2.u.d) :
(mn1.u.l > mn2.u.l));
case COND_LE:
return !((mn1.type & MN_FLOAT) ? (mn1.u.d <= mn2.u.d) :
(mn1.u.l <= mn2.u.l));
case COND_GE:
return !((mn1.type & MN_FLOAT) ? (mn1.u.d >= mn2.u.d) :
(mn1.u.l >= mn2.u.l));
}
}
switch (ctype) {
case COND_STREQ:
case COND_STRNEQ:
{
int test, npat = state->pc[1];
Patprog pprog = state->prog->pats[npat];
if (pprog == dummy_patprog1 || pprog == dummy_patprog2) {
char *opat;
int save;
right = dupstring(opat = ecrawstr(state->prog, state->pc,
&htok));
singsub(&right);
save = (!(state->prog->flags & EF_HEAP) &&
!strcmp(opat, right) && pprog != dummy_patprog2);
if (!(pprog = patcompile(right, (save ? PAT_ZDUP : PAT_STATIC),
NULL))) {
zwarnnam(fromtest, "bad pattern: %s", right);
return 2;
}
else if (save)
state->prog->pats[npat] = pprog;
}
state->pc += 2;
test = (pprog && pattry(pprog, left));
return !(ctype == COND_STREQ ? test : !test);
}
case COND_STRLT:
return !(strcmp(left, right) < 0);
case COND_STRGTR:
return !(strcmp(left, right) > 0);
case 'e':
case 'a':
return (!doaccess(left, F_OK));
case 'b':
return (!S_ISBLK(dostat(left)));
case 'c':
return (!S_ISCHR(dostat(left)));
case 'd':
return (!S_ISDIR(dostat(left)));
case 'f':
return (!S_ISREG(dostat(left)));
case 'g':
return (!(dostat(left) & S_ISGID));
case 'k':
return (!(dostat(left) & S_ISVTX));
case 'n':
return (!strlen(left));
case 'o':
return (optison(fromtest, left));
case 'p':
return (!S_ISFIFO(dostat(left)));
case 'r':
return (!doaccess(left, R_OK));
case 's':
return !((st = getstat(left)) && !!(st->st_size));
case 'S':
return (!S_ISSOCK(dostat(left)));
case 'u':
return (!(dostat(left) & S_ISUID));
case 'w':
return (!doaccess(left, W_OK));
case 'x':
if (privasserted()) {
mode_t mode = dostat(left);
return !((mode & S_IXUGO) || S_ISDIR(mode));
}
return !doaccess(left, X_OK);
case 'z':
return !!(strlen(left));
case 'h':
case 'L':
return (!S_ISLNK(dolstat(left)));
case 'O':
return !((st = getstat(left)) && st->st_uid == geteuid());
case 'G':
return !((st = getstat(left)) && st->st_gid == getegid());
case 'N':
#if defined(GET_ST_MTIME_NSEC) && defined(GET_ST_ATIME_NSEC)
if (!(st = getstat(left)))
return 1;
return (st->st_atime == st->st_mtime) ?
GET_ST_ATIME_NSEC(*st) > GET_ST_MTIME_NSEC(*st) :
st->st_atime > st->st_mtime;
#else
return !((st = getstat(left)) && st->st_atime <= st->st_mtime);
#endif
case 't':
return !isatty(mathevali(left));
case COND_NT:
case COND_OT:
{
time_t a;
#ifdef GET_ST_MTIME_NSEC
long nsecs;
#endif
if (!(st = getstat(left)))
return 1;
a = st->st_mtime;
#ifdef GET_ST_MTIME_NSEC
nsecs = GET_ST_MTIME_NSEC(*st);
#endif
if (!(st = getstat(right)))
return 1;
#ifdef GET_ST_MTIME_NSEC
if (a == st->st_mtime) {
return !((ctype == COND_NT) ? nsecs > GET_ST_MTIME_NSEC(*st) :
nsecs < GET_ST_MTIME_NSEC(*st));
}
#endif
return !((ctype == COND_NT) ? a > st->st_mtime : a < st->st_mtime);
}
case COND_EF:
{
dev_t d;
ino_t i;
if (!(st = getstat(left)))
return 1;
d = st->st_dev;
i = st->st_ino;
if (!(st = getstat(right)))
return 1;
return !(d == st->st_dev && i == st->st_ino);
}
default:
zwarnnam(fromtest, "bad cond code");
return 2;
}
}
static int
putpromptchar(int doprint, int endchar, unsigned int *txtchangep)
{
char *ss, *hostnam;
int t0, arg, test, sep, j, numjobs;
struct tm *tm;
struct timezone dummy_tz;
struct timeval tv;
time_t timet;
Nameddir nd;
for (; *bv->fm && *bv->fm != endchar; bv->fm++) {
arg = 0;
if (*bv->fm == '%' && isset(PROMPTPERCENT)) {
int minus = 0;
bv->fm++;
if (*bv->fm == '-') {
minus = 1;
bv->fm++;
}
if (idigit(*bv->fm)) {
arg = zstrtol(bv->fm, &bv->fm, 10);
if (minus)
arg *= -1;
} else if (minus)
arg = -1;
if (*bv->fm == '(') {
int tc, otruncwidth;
if (idigit(*++bv->fm)) {
arg = zstrtol(bv->fm, &bv->fm, 10);
} else if (arg < 0) {
/* negative numbers don't make sense here */
arg *= -1;
}
test = 0;
ss = pwd;
switch (tc = *bv->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':
*bv->bp = '\0';
countprompt(bv->bufline, &t0, 0, 0);
if (minus)
t0 = zterm_columns - t0;
if (t0 >= arg)
test = 1;
break;
case 'e':
{
Funcstack fsptr = funcstack;
test = arg;
while (fsptr && test > 0) {
test--;
fsptr = fsptr->prev;
}
test = !test;
}
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 'V':
if (arrlen(psvar) >= arg) {
if (*psvar[(arg ? arg : 1) - 1])
test = 1;
}
break;
case '_':
test = (cmdsp >= arg);
break;
case '!':
test = privasserted();
break;
default:
test = -1;
break;
}
if (!*bv->fm || !(sep = *++bv->fm))
return 0;
bv->fm++;
/* Don't do the current truncation until we get back */
otruncwidth = bv->truncwidth;
bv->truncwidth = 0;
if (!putpromptchar(test == 1 && doprint, sep,
txtchangep) || !*++bv->fm ||
!putpromptchar(test == 0 && doprint, ')',
txtchangep)) {
bv->truncwidth = otruncwidth;
return 0;
}
bv->truncwidth = otruncwidth;
continue;
}
if (!doprint)
switch(*bv->fm) {
case '[':
while(idigit(*++bv->fm));
while(*++bv->fm != ']');
continue;
case '<':
while(*++bv->fm != '<');
continue;
case '>':
while(*++bv->fm != '>');
continue;
case 'D':
if(bv->fm[1]=='{')
while(*++bv->fm != '}');
continue;
default:
continue;
}
switch (*bv->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(bv->bp, curhist, 10);
bv->bp += strlen(bv->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(bv->bp, "%d", numjobs);
bv->bp += strlen(bv->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(txtchangep, TXTSTANDOUT, TXTNOSTANDOUT);
txtset(TXTSTANDOUT);
tsetcap(TCSTANDOUTBEG, TSC_PROMPT);
break;
case 's':
txtchangeset(txtchangep, TXTNOSTANDOUT, TXTSTANDOUT);
txtunset(TXTSTANDOUT);
tsetcap(TCSTANDOUTEND, TSC_PROMPT|TSC_DIRTY);
break;
case 'B':
txtchangeset(txtchangep, TXTBOLDFACE, TXTNOBOLDFACE);
txtset(TXTBOLDFACE);
tsetcap(TCBOLDFACEBEG, TSC_PROMPT|TSC_DIRTY);
break;
case 'b':
txtchangeset(txtchangep, TXTNOBOLDFACE, TXTBOLDFACE);
txtchangeset(txtchangep, TXTNOSTANDOUT, TXTSTANDOUT);
txtchangeset(txtchangep, TXTNOUNDERLINE, TXTUNDERLINE);
txtunset(TXTBOLDFACE);
tsetcap(TCALLATTRSOFF, TSC_PROMPT|TSC_DIRTY);
break;
case 'U':
txtchangeset(txtchangep, TXTUNDERLINE, TXTNOUNDERLINE);
txtset(TXTUNDERLINE);
tsetcap(TCUNDERLINEBEG, TSC_PROMPT);
break;
case 'u':
txtchangeset(txtchangep, TXTNOUNDERLINE, TXTUNDERLINE);
txtunset(TXTUNDERLINE);
tsetcap(TCUNDERLINEEND, TSC_PROMPT|TSC_DIRTY);
break;
case 'F':
arg = parsecolorchar(arg, 1);
if (arg >= 0 && !(arg & TXTNOFGCOLOUR)) {
txtchangeset(txtchangep, arg & TXT_ATTR_FG_ON_MASK,
TXTNOFGCOLOUR);
txtset(arg & TXT_ATTR_FG_ON_MASK);
set_colour_attribute(arg, COL_SEQ_FG, TSC_PROMPT);
break;
}
/* else FALLTHROUGH */
case 'f':
txtchangeset(txtchangep, TXTNOFGCOLOUR, TXT_ATTR_FG_ON_MASK);
txtunset(TXT_ATTR_FG_ON_MASK);
set_colour_attribute(TXTNOFGCOLOUR, COL_SEQ_FG, TSC_PROMPT);
break;
case 'K':
arg = parsecolorchar(arg, 0);
if (arg >= 0 && !(arg & TXTNOBGCOLOUR)) {
txtchangeset(txtchangep, arg & TXT_ATTR_BG_ON_MASK,
TXTNOBGCOLOUR);
txtset(arg & TXT_ATTR_BG_ON_MASK);
set_colour_attribute(arg, COL_SEQ_BG, TSC_PROMPT);
break;
}
/* else FALLTHROUGH */
case 'k':
txtchangeset(txtchangep, TXTNOBGCOLOUR, TXT_ATTR_BG_ON_MASK);
txtunset(TXT_ATTR_BG_ON_MASK);
set_colour_attribute(TXTNOBGCOLOUR, COL_SEQ_BG, TSC_PROMPT);
break;
case '[':
if (idigit(*++bv->fm))
arg = zstrtol(bv->fm, &bv->fm, 10);
if (!prompttrunc(arg, ']', doprint, endchar, txtchangep))
return *bv->fm;
break;
case '<':
case '>':
/* Test (minus) here so -0 means "at the right margin" */
if (minus) {
*bv->bp = '\0';
countprompt(bv->bufline, &t0, 0, 0);
arg = zterm_columns - t0 + arg;
if (arg <= 0)
arg = 1;
}
if (!prompttrunc(arg, *bv->fm, doprint, endchar, txtchangep))
return *bv->fm;
break;
case '{': /*}*/
if (!bv->dontcount++) {
addbufspc(1);
*bv->bp++ = Inpar;
}
if (arg <= 0)
break;
/* else */
/* FALLTHROUGH */
case 'G':
if (arg > 0) {
addbufspc(arg);
while (arg--)
*bv->bp++ = Nularg;
} else {
addbufspc(1);
*bv->bp++ = Nularg;
}
break;
case /*{*/ '}':
if (bv->trunccount && bv->trunccount >= bv->dontcount)
return *bv->fm;
if (bv->dontcount && !--bv->dontcount) {
addbufspc(1);
*bv->bp++ = Outpar;
}
break;
case 't':
case '@':
case 'T':
case '*':
case 'w':
case 'W':
case 'D':
{
char *tmfmt, *dd, *tmbuf = NULL;
switch (*bv->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 (bv->fm[1] == '{' /*}*/) {
for (ss = bv->fm + 2; *ss && *ss != /*{*/ '}'; ss++)
if(*ss == '\\' && ss[1])
ss++;
dd = tmfmt = tmbuf = zalloc(ss - bv->fm);
for (ss = bv->fm + 2; *ss && *ss != /*{*/ '}';
ss++) {
if(*ss == '\\' && ss[1])
ss++;
*dd++ = *ss;
}
*dd = 0;
bv->fm = ss - !*ss;
if (!*tmfmt) {
free(tmbuf);
continue;
}
} else
tmfmt = "%y-%m-%d";
break;
default:
tmfmt = "%l:%M%p";
break;
}
gettimeofday(&tv, &dummy_tz);
tm = localtime(&tv.tv_sec);
/*
* Hack because strftime won't say how
* much space it actually needs. Try to add it
* a few times until it works. Some formats don't
* actually have a length, so we could go on for
* ever.
*/
for(j = 0, t0 = strlen(tmfmt)*8; j < 3; j++, t0*=2) {
addbufspc(t0);
if (ztrftime(bv->bp, t0, tmfmt, tm, tv.tv_usec) >= 0)
break;
}
/* There is enough room for this because addbufspc(t0)
* allocates room for t0 * 2 bytes. */
metafy(bv->bp, -1, META_NOALLOC);
bv->bp += strlen(bv->bp);
zsfree(tmbuf);
break;
}
case 'n':
stradd(get_username());
break;
case 'l':
if (*ttystrname) {
ss = (strncmp(ttystrname, "/dev/tty", 8) ?
ttystrname + 5 : ttystrname + 8);
stradd(ss);
} else
stradd("()");
break;
case 'y':
if (*ttystrname) {
ss = (strncmp(ttystrname, "/dev/", 5) ?
ttystrname : ttystrname + 5);
stradd(ss);
} else
stradd("()");
break;
case 'L':
addbufspc(DIGBUFSIZE);
#if defined(ZLONG_IS_LONG_LONG) && defined(PRINTF_HAS_LLD)
sprintf(bv->bp, "%lld", shlvl);
#else
sprintf(bv->bp, "%ld", (long)shlvl);
#endif
bv->bp += strlen(bv->bp);
break;
case '?':
addbufspc(DIGBUFSIZE);
#if defined(ZLONG_IS_LONG_LONG) && defined(PRINTF_HAS_LLD)
sprintf(bv->bp, "%lld", lastval);
#else
sprintf(bv->bp, "%ld", (long)lastval);
#endif
bv->bp += strlen(bv->bp);
break;
case '%':
case ')':
addbufspc(1);
*bv->bp++ = *bv->fm;
break;
case '#':
addbufspc(1);
*bv->bp++ = privasserted() ? '#' : '%';
break;
case 'v':
if (!arg)
arg = 1;
else if (arg < 0)
arg += arrlen(psvar) + 1;
if (arg > 0 && arrlen(psvar) >= arg)
stradd(psvar[arg - 1]);
break;
case 'E':
tsetcap(TCCLEAREOL, TSC_PROMPT);
break;
case '^':
if (cmdsp) {
if (arg >= 0) {
if (arg > cmdsp || arg == 0)
arg = cmdsp;
for (t0 = cmdsp - 1; arg--; t0--) {
stradd(cmdnames[cmdstack[t0]]);
if (arg) {
addbufspc(1);
*bv->bp++=' ';
}
}
} else {
arg = -arg;
if (arg > cmdsp)
arg = cmdsp;
for (t0 = arg - 1; arg--; t0--) {
stradd(cmdnames[cmdstack[t0]]);
if (arg) {
addbufspc(1);
*bv->bp++=' ';
}
}
}
}
break;
case '_':
if (cmdsp) {
if (arg >= 0) {
if (arg > cmdsp || arg == 0)
arg = cmdsp;
for (t0 = cmdsp - arg; arg--; t0++) {
stradd(cmdnames[cmdstack[t0]]);
if (arg) {
addbufspc(1);
*bv->bp++=' ';
}
}
} else {
arg = -arg;
if (arg > cmdsp)
arg = cmdsp;
for (t0 = 0; arg--; t0++) {
stradd(cmdnames[cmdstack[t0]]);
if (arg) {
addbufspc(1);
*bv->bp++=' ';
}
}
}
}
break;
case 'r':
if(bv->rstring)
stradd(bv->rstring);
break;
case 'R':
if(bv->Rstring)
stradd(bv->Rstring);
break;
case 'e':
{
int depth = 0;
Funcstack fsptr = funcstack;
while (fsptr) {
depth++;
fsptr = fsptr->prev;
}
addbufspc(DIGBUFSIZE);
sprintf(bv->bp, "%d", depth);
bv->bp += strlen(bv->bp);
break;
}
case 'I':
if (funcstack && funcstack->tp != FS_SOURCE &&
!IN_EVAL_TRAP()) {
/*
* We're in a function or an eval with
* EVALLINENO. Calculate the line number in
* the file.
*/
zlong flineno = lineno + funcstack->flineno;
/* take account of eval line nos. starting at 1 */
if (funcstack->tp == FS_EVAL)
lineno--;
addbufspc(DIGBUFSIZE);
#if defined(ZLONG_IS_LONG_LONG) && defined(PRINTF_HAS_LLD)
sprintf(bv->bp, "%lld", flineno);
#else
sprintf(bv->bp, "%ld", (long)flineno);
#endif
bv->bp += strlen(bv->bp);
break;
}
/* else we're in a file and lineno is already correct */
/* FALLTHROUGH */
case 'i':
addbufspc(DIGBUFSIZE);
#if defined(ZLONG_IS_LONG_LONG) && defined(PRINTF_HAS_LLD)
sprintf(bv->bp, "%lld", lineno);
#else
sprintf(bv->bp, "%ld", (long)lineno);
#endif
bv->bp += strlen(bv->bp);
break;
case 'x':
if (funcstack && funcstack->tp != FS_SOURCE &&
!IN_EVAL_TRAP())
promptpath(funcstack->filename ? funcstack->filename : "",
arg, 0);
else
promptpath(scriptfilename ? scriptfilename : argzero,
arg, 0);
break;
case '\0':
return 0;
case Meta:
bv->fm++;
break;
}
} else if(*bv->fm == '!' && isset(PROMPTBANG)) {
if(doprint) {
if(bv->fm[1] == '!') {
bv->fm++;
addbufspc(1);
pputc('!');
} else {
addbufspc(DIGBUFSIZE);
convbase(bv->bp, curhist, 10);
bv->bp += strlen(bv->bp);
}
}
} else {
char c = *bv->fm == Meta ? *++bv->fm ^ 32 : *bv->fm;
if (doprint) {
addbufspc(1);
pputc(c);
}
}
}
return *bv->fm;
}
