/**
* Widget method that will be called when a tab key is pressed.
*/
static int rift_generate_help(UNUSED(char** arg))
{
/* Metafy - changes the zleline to string and stores in zlemetaline
* zleline is not in string format */
metafy_line();
rwcli_generate_help(zlemetaline);
fflush(stdout);
unmetafy_line();
/* zlemeta* is not valid beyond this point */
// trash the old line and redraw
trashzle();
return 0;
}
/**
* Widget method that will be called when a tab key is pressed.
*/
static int rift_complete(UNUSED(char** arg))
{
int new_len = 0;
char *new_line = NULL;
int i = 0;
/* Metafy - changes the zleline to string and stores in zlemetaline
* zleline is not in string format */
metafy_line();
for (i = 0; zlemetaline[i] != '\0'; i++) {
if (zlemetaline[i] == '|' || zlemetaline[i] == '>') {
unmetafy_line();
execzlefunc(rwcli_controller.t_orig_tab_bind, zlenoargs, 0);
return 0;
}
}
new_line = rwcli_tab_complete(zlemetaline);
fflush(stdout);
if (new_line) {
new_len = strlen(new_line);
if ((new_len > 1 && new_line[new_len - 1] != ' ') ||
(zlemetall == new_len)) {
trash_line();
}
// First truncate the zlemetaline and then insert the new line
// zlemetacs is the cursor, zlemetall is the line length
zlemetacs = 0;
foredel(zlemetall, CUT_RAW);
inststrlen(new_line, new_len, new_len);
free(new_line);
} else {
trash_line();
zlemetacs = 0;
foredel(zlemetall, CUT_RAW);
}
unmetafy_line();
/* zlemeta* is not valid beyond this point */
return 0;
}
mod_export void
handleundo(void)
{
int remetafy;
/*
* Yuk: we call this from within the completion system,
* so we need to convert back to the form which can be
* copied into undo entries.
*/
if (zlemetaline != NULL) {
unmetafy_line();
remetafy = 1;
} else
remetafy = 0;
mkundoent();
if(nextchanges) {
setlastline();
if(curchange->next) {
freechanges(curchange->next);
curchange->next = NULL;
free(curchange->del);
free(curchange->ins);
curchange->del = curchange->ins = NULL;
curchange->dell = curchange->insl = 0;
}
nextchanges->prev = curchange->prev;
if(curchange->prev)
curchange->prev->next = nextchanges;
else
changes = nextchanges;
curchange->prev = endnextchanges;
endnextchanges->next = curchange;
nextchanges = endnextchanges = NULL;
}
if (remetafy)
metafy_line();
}
mod_export void
iremovesuffix(ZLE_INT_T c, int keep)
{
if (suffixfunc) {
Shfunc shfunc = getshfunc(suffixfunc);
if (shfunc) {
LinkList args = newlinklist();
char buf[20];
int osc = sfcontext;
int wasmeta = (zlemetaline != 0);
if (wasmeta) {
/*
* The suffix removal function runs as a normal
* ZLE function, not a completion function, so
* the line should be unmetafied if this was
* called from completion. (It may not be since
* we may decide to remove the suffix later.)
*/
unmetafy_line();
}
sprintf(buf, "%d", suffixfunclen);
addlinknode(args, suffixfunc);
addlinknode(args, buf);
startparamscope();
makezleparams(0);
sfcontext = SFC_COMPLETE;
doshfunc(shfunc, args, 1);
sfcontext = osc;
endparamscope();
if (wasmeta)
metafy_line();
}
zsfree(suffixfunc);
suffixfunc = NULL;
} else {
int sl = 0, flags = 0;
struct suffixset *ss;
if (c == NO_INSERT_CHAR) {
sl = suffixnoinsrem ? suffixlen : 0;
} else {
ZLE_CHAR_T ch = c;
/*
* Search for a match for ch in the suffix list.
* We stop if we encounter a match in a positive or negative
* list, using the suffix length specified or zero respectively.
* If we reached the end and passed through a negative
* list, we use the suffix length for that, else zero.
* This would break if it were possible to have negative
* sets with different suffix length: that's not supposed
* to happen.
*/
int negsuflen = 0, found = 0;
for (ss = suffixlist; ss; ss = ss->next) {
switch (ss->tp) {
case SUFTYP_POSSTR:
if (ZS_memchr(ss->chars, ch, ss->lenstr)) {
sl = ss->lensuf;
found = 1;
}
break;
case SUFTYP_NEGSTR:
if (ZS_memchr(ss->chars, ch, ss->lenstr)) {
sl = 0;
found = 1;
} else {
negsuflen = ss->lensuf;
}
break;
case SUFTYP_POSRNG:
if (ss->chars[0] <= ch && ch <= ss->chars[1]) {
sl = ss->lensuf;
found = 1;
}
break;
case SUFTYP_NEGRNG:
if (ss->chars[0] <= ch && ch <= ss->chars[1]) {
sl = 0;
found = 1;
} else {
negsuflen = ss->lensuf;
}
break;
}
if (found) {
flags = ss->flags;
break;
}
}
if (!found)
sl = negsuflen;
}
if (sl) {
/* must be shifting wide character lengths */
backdel(sl, CUT_RAW);
if (flags & SUFFLAGS_SPACE)
{
/* Add a space and advance over it */
spaceinline(1);
if (zlemetaline) {
zlemetaline[zlemetacs++] = ' ';
} else {
zleline[zlecs++] = ZWC(' ');
}
}
if (!keep)
invalidatelist();
}
}
fixsuffix();
}
/**
* Clear the current ZLE line
*/
static void trash_line() {
unmetafy_line();
trashzle();
metafy_line();
}
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;
}
