static int
bin_vared(char *name, char **args, Options ops, UNUSED(int func))
{
char *s, *t, *ova = varedarg;
struct value vbuf;
Value v;
Param pm = 0;
int ifl;
int type = PM_SCALAR, obreaks = breaks, haso = 0, oSHTTY = 0;
char *p1, *p2, *main_keymapname, *vicmd_keymapname, *init, *finish;
Keymap main_keymapsave = NULL, vicmd_keymapsave = NULL;
FILE *oshout = NULL;
if ((interact && unset(USEZLE)) || !strcmp(term, "emacs")) {
zwarnnam(name, "ZLE not enabled");
return 1;
}
if (zleactive) {
zwarnnam(name, "ZLE cannot be used recursively (yet)");
return 1;
}
if (OPT_ISSET(ops,'A'))
{
if (OPT_ISSET(ops, 'a'))
{
zwarnnam(name, "specify only one of -a and -A");
return 1;
}
type = PM_HASHED;
}
else if (OPT_ISSET(ops,'a'))
type = PM_ARRAY;
p1 = OPT_ARG_SAFE(ops,'p');
p2 = OPT_ARG_SAFE(ops,'r');
main_keymapname = OPT_ARG_SAFE(ops,'M');
vicmd_keymapname = OPT_ARG_SAFE(ops,'m');
init = OPT_ARG_SAFE(ops,'i');
finish = OPT_ARG_SAFE(ops,'f');
if (type != PM_SCALAR && !OPT_ISSET(ops,'c')) {
zwarnnam(name, "-%s ignored", type == PM_ARRAY ? "a" : "A");
}
/* handle non-existent parameter */
s = args[0];
queue_signals();
v = fetchvalue(&vbuf, &s, (!OPT_ISSET(ops,'c') || type == PM_SCALAR),
SCANPM_WANTKEYS|SCANPM_WANTVALS|SCANPM_MATCHMANY);
if (!v && !OPT_ISSET(ops,'c')) {
unqueue_signals();
zwarnnam(name, "no such variable: %s", args[0]);
return 1;
} else if (v) {
if (*s) {
zwarnnam(name, "not an identifier: `%s'", args[0]);
return 1;
}
if (v->isarr) {
/* Array: check for separators and quote them. */
char **arr = getarrvalue(v), **aptr, **tmparr, **tptr;
tptr = tmparr = (char **)zhalloc(sizeof(char *)*(arrlen(arr)+1));
for (aptr = arr; *aptr; aptr++) {
int sepcount = 0, clen;
convchar_t c;
/*
* See if this word contains a separator character
* or backslash
*/
MB_METACHARINIT();
for (t = *aptr; *t; ) {
if (*t == '\\') {
t++;
sepcount++;
} else {
t += MB_METACHARLENCONV(t, &c);
if (WC_ZISTYPE(c, ISEP))
sepcount++;
}
}
if (sepcount) {
/* Yes, so allocate enough space to quote it. */
char *newstr, *nptr;
newstr = zhalloc(strlen(*aptr)+sepcount+1);
/* Go through string quoting separators */
MB_METACHARINIT();
for (t = *aptr, nptr = newstr; *t; ) {
if (*t == '\\') {
*nptr++ = '\\';
*nptr++ = *t++;
} else {
clen = MB_METACHARLENCONV(t, &c);
if (WC_ZISTYPE(c, ISEP))
*nptr++ = '\\';
while (clen--)
*nptr++ = *t++;
}
}
*nptr = '\0';
/* Stick this into the array of words to join up */
*tptr++ = newstr;
} else
*tptr++ = *aptr; /* No, keep original array element */
}
*tptr = NULL;
s = sepjoin(tmparr, NULL, 0);
} else {
s = ztrdup(getstrvalue(v));
}
unqueue_signals();
} else if (*s) {
unqueue_signals();
zwarnnam(name, "invalid parameter name: %s", args[0]);
return 1;
} else {
unqueue_signals();
s = ztrdup(s);
}
if (SHTTY == -1 || OPT_ISSET(ops,'t')) {
/* need to open /dev/tty specially */
oSHTTY = SHTTY;
if ((SHTTY = open(OPT_ISSET(ops,'t') ? OPT_ARG(ops,'t') : "/dev/tty",
O_RDWR|O_NOCTTY)) == -1) {
zwarnnam(name, "can't access terminal");
zsfree(s);
return 1;
}
if (!isatty(SHTTY)) {
zwarnnam(name, "%s: not a terminal", OPT_ARG(ops,'t'));
close(SHTTY);
SHTTY = oSHTTY;
zsfree(s);
return 1;
}
oshout = shout;
init_shout();
haso = 1;
}
/* edit the parameter value */
zpushnode(bufstack, s);
if (main_keymapname &&
savekeymap(name, "main", main_keymapname, &main_keymapsave))
main_keymapname = NULL;
if (vicmd_keymapname &&
savekeymap(name, "vicmd", vicmd_keymapname, &vicmd_keymapsave))
vicmd_keymapname = NULL;
varedarg = *args;
ifl = isfirstln;
if (OPT_ISSET(ops,'h'))
hbegin(2);
isfirstln = OPT_ISSET(ops,'e');
t = zleread(&p1, &p2, OPT_ISSET(ops,'h') ? ZLRF_HISTORY : 0, ZLCON_VARED,
init ? init : "zle-line-init",
finish ? finish : "zle-line-finish");
if (OPT_ISSET(ops,'h'))
hend(NULL);
isfirstln = ifl;
varedarg = ova;
restorekeymap(name, "main", main_keymapname, main_keymapsave);
restorekeymap(name, "vicmd", vicmd_keymapname, vicmd_keymapsave);
if (haso) {
fclose(shout); /* close(SHTTY) */
shout = oshout;
SHTTY = oSHTTY;
}
if (!t || errflag) {
/* error in editing */
errflag &= ~ERRFLAG_ERROR;
breaks = obreaks;
if (t)
zsfree(t);
return 1;
}
/* strip off trailing newline, if any */
if (t[strlen(t) - 1] == '\n')
t[strlen(t) - 1] = '\0';
/* final assignment of parameter value */
if (OPT_ISSET(ops,'c')) {
unsetparam(args[0]);
createparam(args[0], type);
}
queue_signals();
pm = (Param) paramtab->getnode(paramtab, args[0]);
if (pm && (PM_TYPE(pm->node.flags) & (PM_ARRAY|PM_HASHED))) {
char **a;
/*
* Use spacesplit with fourth argument 1: identify quoted separators,
* and unquote. This duplicates the string, so we still need to free.
*/
a = spacesplit(t, 1, 0, 1);
zsfree(t);
if (PM_TYPE(pm->node.flags) == PM_ARRAY)
setaparam(args[0], a);
else
sethparam(args[0], a);
} else
setsparam(args[0], t);
unqueue_signals();
return 0;
}
char *
zleread(char **lp, char **rp, int flags, int context)
{
char *s;
int old_errno = errno;
int tmout = getiparam("TMOUT");
#if defined(HAVE_POLL) || defined(HAVE_SELECT)
/* may not be set, but that's OK since getiparam() returns 0 == off */
baud = getiparam("BAUD");
costmult = (baud) ? 3840000L / baud : 0;
#endif
/* ZLE doesn't currently work recursively. This is needed in case a *
* select loop is used in a function called from ZLE. vared handles *
* this differently itself. */
if(zleactive) {
char *pptbuf;
int pptlen;
pptbuf = unmetafy(promptexpand(lp ? *lp : NULL, 0, NULL, NULL,
&pmpt_attr),
&pptlen);
write_loop(2, pptbuf, pptlen);
free(pptbuf);
return shingetline();
}
/*
* The current status is what we need if we are going
* to display a prompt. We'll remember it here for
* use further in.
*/
pre_zle_status = lastval;
keytimeout = (time_t)getiparam("KEYTIMEOUT");
if (!shout) {
if (SHTTY != -1)
init_shout();
if (!shout)
return NULL;
/* We could be smarter and default to a system read. */
/* If we just got a new shout, make sure the terminal is set up. */
if (termflags & TERM_UNKNOWN)
init_term();
}
fflush(shout);
fflush(stderr);
intr();
insmode = unset(OVERSTRIKE);
eofsent = 0;
resetneeded = 0;
fetchttyinfo = 0;
trashedzle = 0;
raw_lp = lp;
lpromptbuf = promptexpand(lp ? *lp : NULL, 1, NULL, NULL, &pmpt_attr);
raw_rp = rp;
rpmpt_attr = pmpt_attr;
rpromptbuf = promptexpand(rp ? *rp : NULL, 1, NULL, NULL, &rpmpt_attr);
free_prepostdisplay();
zlereadflags = flags;
zlecontext = context;
histline = curhist;
undoing = 1;
zleline = (ZLE_STRING_T)zalloc(((linesz = 256) + 2) * ZLE_CHAR_SIZE);
*zleline = ZWC('\0');
virangeflag = lastcmd = done = zlecs = zlell = mark = 0;
vichgflag = 0;
viinsbegin = 0;
statusline = NULL;
selectkeymap("main", 1);
selectlocalmap(NULL);
fixsuffix();
if ((s = getlinknode(bufstack))) {
setline(s, ZSL_TOEND);
zsfree(s);
if (stackcs != -1) {
zlecs = stackcs;
stackcs = -1;
if (zlecs > zlell)
zlecs = zlell;
CCLEFT();
}
if (stackhist != -1) {
histline = stackhist;
stackhist = -1;
}
}
initundo();
if (isset(PROMPTCR))
putc('\r', shout);
if (tmout)
alarm(tmout);
zleactive = 1;
resetneeded = 1;
errflag = retflag = 0;
lastcol = -1;
initmodifier(&zmod);
prefixflag = 0;
zrefresh();
zlecallhook("zle-line-init", NULL);
zlecore();
if (errflag)
setsparam("ZLE_LINE_ABORTED", zlegetline(NULL, NULL));
if (done && !exit_pending && !errflag)
zlecallhook("zle-line-finish", NULL);
statusline = NULL;
invalidatelist();
trashzle();
free(lpromptbuf);
free(rpromptbuf);
zleactive = zlereadflags = lastlistlen = zlecontext = 0;
alarm(0);
freeundo();
if (eofsent) {
s = NULL;
} else {
zleline[zlell++] = ZWC('\n');
s = zlegetline(NULL, NULL);
}
free(zleline);
zleline = NULL;
forget_edits();
errno = old_errno;
/* highlight no longer valid */
set_region_highlight(NULL, NULL);
return s;
}
char *
zleread(char **lp, char **rp, int flags, int context, char *init, char *finish)
{
char *s, **bracket;
int old_errno = errno;
int tmout = getiparam("TMOUT");
#if defined(HAVE_POLL) || defined(HAVE_SELECT)
/* may not be set, but that's OK since getiparam() returns 0 == off */
baud = getiparam("BAUD");
costmult = (baud) ? 3840000L / baud : 0;
#endif
/* ZLE doesn't currently work recursively. This is needed in case a *
* select loop is used in a function called from ZLE. vared handles *
* this differently itself. */
if(zleactive) {
char *pptbuf;
int pptlen;
pptbuf = unmetafy(promptexpand(lp ? *lp : NULL, 0, NULL, NULL,
&pmpt_attr),
&pptlen);
write_loop(2, pptbuf, pptlen);
free(pptbuf);
return shingetline();
}
/*
* The current status is what we need if we are going
* to display a prompt. We'll remember it here for
* use further in.
*/
pre_zle_status = lastval;
keytimeout = (time_t)getiparam("KEYTIMEOUT");
if (!shout) {
if (SHTTY != -1)
init_shout();
if (!shout)
return NULL;
/* We could be smarter and default to a system read. */
/* If we just got a new shout, make sure the terminal is set up. */
if (termflags & TERM_UNKNOWN)
init_term();
}
fflush(shout);
fflush(stderr);
intr();
insmode = unset(OVERSTRIKE);
eofsent = 0;
resetneeded = 0;
fetchttyinfo = 0;
trashedzle = 0;
raw_lp = lp;
lpromptbuf = promptexpand(lp ? *lp : NULL, 1, NULL, NULL, &pmpt_attr);
raw_rp = rp;
rpmpt_attr = pmpt_attr;
rpromptbuf = promptexpand(rp ? *rp : NULL, 1, NULL, NULL, &rpmpt_attr);
free_prepostdisplay();
zlereadflags = flags;
zlecontext = context;
histline = curhist;
vistartchange = -1;
zleline = (ZLE_STRING_T)zalloc(((linesz = 256) + 2) * ZLE_CHAR_SIZE);
*zleline = ZWC('\0');
virangeflag = lastcmd = done = zlecs = zlell = mark = 0;
vichgflag = 0;
viinsbegin = 0;
statusline = NULL;
selectkeymap("main", 1);
initundo();
fixsuffix();
if ((s = getlinknode(bufstack))) {
setline(s, ZSL_TOEND);
zsfree(s);
if (stackcs != -1) {
zlecs = stackcs;
stackcs = -1;
if (zlecs > zlell)
zlecs = zlell;
CCLEFT();
}
if (stackhist != -1) {
histline = stackhist;
stackhist = -1;
}
handleundo();
}
/*
* If main is linked to the viins keymap, we need to register
* explicitly that we're now in vi insert mode as there's
* no user operation to indicate this.
*/
if (openkeymap("main") == openkeymap("viins"))
viinsert_init();
selectlocalmap(NULL);
if (isset(PROMPTCR))
putc('\r', shout);
if (tmout)
alarm(tmout);
/*
* On some windowing systems we may enter this function before the
* terminal is fully opened and sized, resulting in an infinite
* series of SIGWINCH when the handler prints the prompt before we
* have done so here. Therefore, hold any such signal until the
* first full refresh has completed. The important bit is that the
* handler must not see zleactive = 1 until ZLE really is active.
* See the end of adjustwinsize() in Src/utils.c
*/
queue_signals();
zleactive = 1;
resetneeded = 1;
/*
* Start of the main zle read.
* Fully reset error conditions, including user interrupt.
*/
errflag = retflag = 0;
lastcol = -1;
initmodifier(&zmod);
prefixflag = 0;
zrefresh();
unqueue_signals(); /* Should now be safe to acknowledge SIGWINCH */
zlecallhook(init, NULL);
if ((bracket = getaparam("zle_bracketed_paste")) && arrlen(bracket) == 2)
fputs(*bracket, shout);
zrefresh();
zlecore();
if (errflag)
setsparam((zlecontext == ZLCON_VARED) ?
"ZLE_VARED_ABORTED" :
"ZLE_LINE_ABORTED", zlegetline(NULL, NULL));
if ((bracket = getaparam("zle_bracketed_paste")) && arrlen(bracket) == 2)
fputs(bracket[1], shout);
if (done && !exit_pending && !errflag)
zlecallhook(finish, NULL);
statusline = NULL;
invalidatelist();
trashzle();
free(lpromptbuf);
free(rpromptbuf);
zleactive = zlereadflags = lastlistlen = zlecontext = 0;
alarm(0);
freeundo();
if (eofsent || errflag || exit_pending) {
s = NULL;
} else {
zleline[zlell++] = ZWC('\n');
s = zlegetline(NULL, NULL);
}
free(zleline);
zleline = NULL;
forget_edits();
errno = old_errno;
/* highlight no longer valid */
set_region_highlight(NULL, NULL);
return s;
}
void
init_io(void)
{
long ttpgrp;
static char outbuf[BUFSIZ], errbuf[BUFSIZ];
#ifdef RSH_BUG_WORKAROUND
int i;
#endif
/* stdout, stderr fully buffered */
#ifdef _IOFBF
setvbuf(stdout, outbuf, _IOFBF, BUFSIZ);
setvbuf(stderr, errbuf, _IOFBF, BUFSIZ);
#else
setbuffer(stdout, outbuf, BUFSIZ);
setbuffer(stderr, errbuf, BUFSIZ);
#endif
/* This works around a bug in some versions of in.rshd. *
* Currently this is not defined by default. */
#ifdef RSH_BUG_WORKAROUND
if (cmd) {
for (i = 3; i < 10; i++)
close(i);
}
#endif
if (shout) {
fclose(shout);
shout = 0;
}
if (SHTTY != -1) {
zclose(SHTTY);
SHTTY = -1;
}
/* Make sure the tty is opened read/write. */
if (isatty(0)) {
zsfree(ttystrname);
if ((ttystrname = ztrdup(ttyname(0))))
SHTTY = movefd(open(ttystrname, O_RDWR));
}
if (SHTTY == -1 && (SHTTY = movefd(open("/dev/tty", O_RDWR))) != -1) {
zsfree(ttystrname);
ttystrname = ztrdup("/dev/tty");
}
if (SHTTY == -1) {
zsfree(ttystrname);
ttystrname = ztrdup("");
}
/* We will only use zle if shell is interactive, *
* SHTTY != -1, and shout != 0 */
if (interact && SHTTY != -1) {
init_shout();
if(!shout)
opts[USEZLE] = 0;
} else
opts[USEZLE] = 0;
#ifdef JOB_CONTROL
/* If interactive, make the shell the foreground process */
if (opts[MONITOR] && interact && (SHTTY != -1)) {
attachtty(GETPGRP());
if ((mypgrp = GETPGRP()) > 0) {
while ((ttpgrp = gettygrp()) != -1 && ttpgrp != mypgrp) {
sleep(1);
mypgrp = GETPGRP();
if (mypgrp == gettygrp())
break;
#ifndef __EMX__
killpg(mypgrp, SIGTTIN);
#endif
mypgrp = GETPGRP();
}
} else
opts[MONITOR] = 0;
} else
opts[MONITOR] = 0;
#else
opts[MONITOR] = 0;
#endif
}
