void
setline(char *s, int flags)
{
char *scp;
UNMETACHECK();
if (flags & ZSL_COPY)
scp = ztrdup(s);
else
scp = s;
/*
* TBD: we could make this more efficient by passing the existing
* allocated line to stringaszleline.
*/
free(zleline);
zleline = stringaszleline(scp, 0, &zlell, &linesz, NULL);
if ((flags & ZSL_TOEND) && (zlecs = zlell) && invicmdmode())
DECCS();
else if (zlecs > zlell)
zlecs = zlell;
CCRIGHT();
if (flags & ZSL_COPY)
free(scp);
}
int
viyank(UNUSED(char **args))
{
int c2, ret = 1;
startvichange(1);
if ((c2 = getvirange(0)) != -1) {
cut(zlecs, c2 - zlecs, CUT_YANK);
ret = 0;
}
vichgflag = 0;
/* cursor now at the start of the range yanked. For line mode
* restore the column position */
if (vilinerange && lastcol != -1) {
int x = findeol();
if ((zlecs += lastcol) >= x) {
zlecs = x;
if (zlecs > findbol() && invicmdmode())
DECCS();
}
#ifdef MULTIBYTE_SUPPORT
else
CCRIGHT();
#endif
lastcol = -1;
}
return ret;
}
mod_export void
backdel(int ct, int flags)
{
if (flags & CUT_RAW) {
if (zlemetaline != NULL) {
shiftchars(zlemetacs -= ct, ct);
} else {
shiftchars(zlecs -= ct, ct);
CCRIGHT();
}
} else {
int n = ct, origcs = zlecs;
DPUTS(zlemetaline != NULL, "backdel needs CUT_RAW when metafied");
while (n--)
DECCS();
shiftchars(zlecs, origcs - zlecs);
CCRIGHT();
}
}
mod_export void
foredel(int ct, int flags)
{
if (flags & CUT_RAW) {
if (zlemetaline != NULL) {
shiftchars(zlemetacs, ct);
} else if (flags & CUT_RAW) {
shiftchars(zlecs, ct);
CCRIGHT();
}
} else {
int origcs = zlecs;
int n = ct;
DPUTS(zlemetaline != NULL, "foredel needs CUT_RAW when metafied");
while (n--)
INCCS();
ct = zlecs - origcs;
zlecs = origcs;
shiftchars(zlecs, ct);
CCRIGHT();
}
}
mod_export void
backkill(int ct, int flags)
{
UNMETACHECK();
if (flags & CUT_RAW) {
zlecs -= ct;
} else {
int origcs = zlecs;
while (ct--)
DECCS();
ct = origcs - zlecs;
}
cut(zlecs, ct, flags);
shiftchars(zlecs, ct);
CCRIGHT();
}
mod_export void
forekill(int ct, int flags)
{
int i = zlecs;
UNMETACHECK();
if (!(flags & CUT_RAW)) {
int n = ct;
while (n--)
INCCS();
ct = zlecs - i;
zlecs = i;
}
cut(i, ct, flags);
shiftchars(i, ct);
CCRIGHT();
}
void
doinsert(ZLE_STRING_T zstr, int len)
{
ZLE_STRING_T s;
ZLE_CHAR_T c1 = *zstr; /* first character */
int neg = zmult < 0; /* insert *after* the cursor? */
int m = neg ? -zmult : zmult; /* number of copies to insert */
int count;
UNMETACHECK();
iremovesuffix(c1, 0);
invalidatelist();
/* In overwrite mode, don't replace newlines. */
if (insmode || zleline[zlecs] == ZWC('\n'))
spaceinline(m * len);
else
{
int pos = zlecs, diff, i;
#ifdef MULTIBYTE_SUPPORT
/*
* Calculate the number of character positions we are
* going to be using. The algorithm is that
* anything that shows up as a logical single character
* (i.e. even if control, or double width, or with combining
* characters) is treated as 1 for the purpose of replacing
* what's there already.
*
* This can cause inserting of a combining character in
* places where it should overwrite, such as the start
* of a line. However, combining characters aren't
* useful there anyway and this doesn't cause any
* particular harm.
*/
for (i = 0, count = 0; i < len * m; i++) {
if (!IS_COMBINING(zstr[i]))
count++;
}
#else
count = len * m;
#endif
/*
* Ensure we replace a complete combining characterfor each
* character we overwrite. Switch to inserting at first newline.
*/
for (i = count; pos < zlell && zleline[pos] != ZWC('\n') && i--; ) {
INCPOS(pos);
}
/*
* Calculate how many raw line places we need.
* pos - zlecs is the raw line distance we're replacing,
* m * len the number we're inserting.
*/
diff = pos - zlecs - m * len;
if (diff < 0) {
spaceinline(-diff);
} else if (diff > 0) {
/*
* We use shiftchars() here because we don't
* want combining char alignment fixed up: we
* are going to write over any that remain.
*/
shiftchars(zlecs, diff);
}
}
while (m--)
for (s = zstr, count = len; count; s++, count--)
zleline[zlecs++] = *s;
if (neg)
zlecs += zmult * len;
/* if we ended up on a combining character, skip over it */
CCRIGHT();
}
int
execzlefunc(Thingy func, char **args, int set_bindk)
{
int r = 0, ret = 0, remetafy = 0;
Widget w;
Thingy save_bindk = bindk;
if (set_bindk)
bindk = func;
if (zlemetaline) {
unmetafy_line();
remetafy = 1;
}
if(func->flags & DISABLED) {
/* this thingy is not the name of a widget */
char *nm = nicedup(func->nam, 0);
char *msg = tricat("No such widget `", nm, "'");
zsfree(nm);
showmsg(msg);
zsfree(msg);
ret = 1;
} else if((w = func->widget)->flags & (WIDGET_INT|WIDGET_NCOMP)) {
int wflags = w->flags;
/*
* The rule is that "zle -N" widgets suppress EOF warnings. When
* a "zle -N" widget invokes "zle another-widget" we pass through
* this code again, but with actual arguments rather than with the
* zlenoargs placeholder.
*/
if (keybuf[0] == eofchar && !keybuf[1] && args == zlenoargs &&
!zlell && isfirstln && (zlereadflags & ZLRF_IGNOREEOF)) {
showmsg((!islogin) ? "zsh: use 'exit' to exit." :
"zsh: use 'logout' to logout.");
use_exit_printed = 1;
eofsent = 1;
ret = 1;
} else {
if(!(wflags & ZLE_KEEPSUFFIX))
removesuffix();
if(!(wflags & ZLE_MENUCMP)) {
fixsuffix();
invalidatelist();
}
if (wflags & ZLE_LINEMOVE)
vilinerange = 1;
if(!(wflags & ZLE_LASTCOL))
lastcol = -1;
if (wflags & WIDGET_NCOMP) {
int atcurhist = histline == curhist;
compwidget = w;
ret = completecall(args);
if (atcurhist)
histline = curhist;
} else if (!w->u.fn) {
handlefeep(zlenoargs);
} else {
queue_signals();
ret = w->u.fn(args);
unqueue_signals();
}
if (!(wflags & ZLE_NOTCOMMAND))
lastcmd = wflags;
}
r = 1;
} else {
Shfunc shf = (Shfunc) shfunctab->getnode(shfunctab, w->u.fnnam);
if (!shf) {
/* the shell function doesn't exist */
char *nm = nicedup(w->u.fnnam, 0);
char *msg = tricat("No such shell function `", nm, "'");
zsfree(nm);
showmsg(msg);
zsfree(msg);
ret = 1;
} else {
int osc = sfcontext, osi = movefd(0);
int oxt = isset(XTRACE);
LinkList largs = NULL;
if (*args) {
largs = newlinklist();
addlinknode(largs, dupstring(w->u.fnnam));
while (*args)
addlinknode(largs, dupstring(*args++));
}
startparamscope();
makezleparams(0);
sfcontext = SFC_WIDGET;
opts[XTRACE] = 0;
ret = doshfunc(shf, largs, 1);
opts[XTRACE] = oxt;
sfcontext = osc;
endparamscope();
lastcmd = w->flags;
w->flags = 0;
r = 1;
redup(osi, 0);
}
}
if (r) {
unrefthingy(lbindk);
refthingy(func);
lbindk = func;
}
if (set_bindk)
bindk = save_bindk;
/*
* Goodness knows where the user's left us; make sure
* it's not on a combining character that won't be displayed
* directly.
*/
CCRIGHT();
if (remetafy)
metafy_line();
return ret;
}
